From 8c90e7cafcec130e752207657239e61166082813 Mon Sep 17 00:00:00 2001 From: Gregory Hainaut Date: Sun, 9 Nov 2014 17:23:17 +0100 Subject: [PATCH] gsdx-ogl: support latest fxaa version Only tested on Nvidia, please report any issue with your driver Note: requires GL4 GPU --- linux_various/glsl2h.pl | 3 +- plugins/GSdx/GSDeviceOGL.cpp | 20 +- plugins/GSdx/res/fxaa.fx | 192 +++- plugins/GSdx/res/glsl_source.h | 1723 ++++++++++---------------------- plugins/GSdx/res/old_fxaa.fx | 1230 ----------------------- 5 files changed, 689 insertions(+), 2479 deletions(-) delete mode 100644 plugins/GSdx/res/old_fxaa.fx diff --git a/linux_various/glsl2h.pl b/linux_various/glsl2h.pl index 226a098306..51b848e38e 100755 --- a/linux_various/glsl2h.pl +++ b/linux_various/glsl2h.pl @@ -34,8 +34,7 @@ eval { print "Disable MD5\n"; }; -# Keep the old FXAA for now -my @gsdx_res = qw/convert.glsl interlace.glsl merge.glsl shadeboost.glsl tfx.glsl old_fxaa.fx/; +my @gsdx_res = qw/convert.glsl interlace.glsl merge.glsl shadeboost.glsl tfx.glsl fxaa.fx/; my $gsdx_path = File::Spec->catdir(dirname(abs_path($0)), "..", "plugins", "GSdx", "res"); my $gsdx_out = File::Spec->catdir($gsdx_path, "glsl_source.h"); glsl2h($gsdx_path, $gsdx_out, \@gsdx_res); diff --git a/plugins/GSdx/GSDeviceOGL.cpp b/plugins/GSdx/GSDeviceOGL.cpp index 785b7c2018..20b6605195 100644 --- a/plugins/GSdx/GSDeviceOGL.cpp +++ b/plugins/GSdx/GSDeviceOGL.cpp @@ -40,7 +40,6 @@ uint32 g_vertex_upload_byte = 0; static const uint32 g_merge_cb_index = 10; static const uint32 g_interlace_cb_index = 11; static const uint32 g_shadeboost_cb_index = 12; -static const uint32 g_fxaa_cb_index = 13; static const uint32 g_fx_cb_index = 14; GSDeviceOGL::GSDeviceOGL() @@ -919,13 +918,15 @@ void GSDeviceOGL::DoFXAA(GSTexture* st, GSTexture* dt) // Lazy compile if (!m_fxaa.ps) { std::string fxaa_macro = "#define FXAA_GLSL_130 1\n"; - if (GLLoader::found_GL_ARB_gpu_shader5) { - // This extension become core on openGL4 + if (GLLoader::found_GL_ARB_gpu_shader5) { // GL4.0 extension + // Hardcoded in the new shader + //fxaa_macro += "#define FXAA_GATHER4_ALPHA 1\n"; fxaa_macro += "#extension GL_ARB_gpu_shader5 : enable\n"; - fxaa_macro += "#define FXAA_GATHER4_ALPHA 1\n"; + } else { + fprintf(stderr, "FXAA requires the GL_ARB_gpu_shader5 extension. Please either disable FXAA or upgrade your GPU/driver.\n"); + return; } - m_fxaa.cb = new GSUniformBufferOGL(g_fxaa_cb_index, sizeof(FXAAConstantBuffer)); - m_fxaa.ps = m_shader->Compile("fxaa.fx", "ps_main", GL_FRAGMENT_SHADER, old_fxaa_fx, fxaa_macro); + m_fxaa.ps = m_shader->Compile("fxaa.fx", "ps_main", GL_FRAGMENT_SHADER, fxaa_fx, fxaa_macro); } GSVector2i s = dt->GetSize(); @@ -933,13 +934,6 @@ void GSDeviceOGL::DoFXAA(GSTexture* st, GSTexture* dt) GSVector4 sr(0, 0, 1, 1); GSVector4 dr(0, 0, s.x, s.y); - FXAAConstantBuffer cb; - - cb.rcpFrame = GSVector4(1.0f / s.x, 1.0f / s.y, 0.0f, 0.0f); - cb.rcpFrameOpt = GSVector4::zero(); - - m_fxaa.cb->upload(&cb); - StretchRect(st, sr, dt, dr, m_fxaa.ps, true); } diff --git a/plugins/GSdx/res/fxaa.fx b/plugins/GSdx/res/fxaa.fx index 20abc8c421..a5e7572c97 100644 --- a/plugins/GSdx/res/fxaa.fx +++ b/plugins/GSdx/res/fxaa.fx @@ -1,4 +1,8 @@ -#ifdef SHADER_MODEL +#if defined(SHADER_MODEL) || defined(FXAA_GLSL_130) + +#ifndef FXAA_GLSL_130 + #define FXAA_GLSL_130 0 +#endif #define UHQ_FXAA 1 //High Quality Fast Approximate Anti Aliasing. Adapted for GSdx from Timothy Lottes FXAA 3.11. #define FxaaSubpixMax 0.0 //[0.00 to 1.00] Amount of subpixel aliasing removal. 0.00: Edge only antialiasing (no blurring) @@ -7,6 +11,29 @@ /*------------------------------------------------------------------------------ [GLOBALS|FUNCTIONS] ------------------------------------------------------------------------------*/ +#if (FXAA_GLSL_130 == 1) + +struct vertex_basic +{ + vec4 p; + vec2 t; +}; + +#ifdef ENABLE_BINDLESS_TEX +layout(bindless_sampler, location = 0) uniform sampler2D TextureSampler; +#else +layout(binding = 0) uniform sampler2D TextureSampler; +#endif + +in SHADER +{ + vec4 p; + vec2 t; +} PSin; + +layout(location = 0) out vec4 SV_Target0; + +#else #if (SHADER_MODEL >= 0x400) Texture2D Texture : register(t0); @@ -47,59 +74,7 @@ struct PS_OUTPUT #endif }; -float RGBLuminance(float3 color) -{ - const float3 lumCoeff = float3(0.2126729, 0.7151522, 0.0721750); - return dot(color.rgb, lumCoeff); -} - -#define PixelSize float2(_rcpFrame.x, _rcpFrame.y) - -/*------------------------------------------------------------------------------ - [GAMMA PREPASS CODE SECTION] -------------------------------------------------------------------------------*/ - -float3 RGBGammaToLinear(float3 color, float gamma) -{ - color = saturate(color); - color.r = (color.r <= 0.0404482362771082) ? - color.r / 12.92 : pow((color.r + 0.055) / 1.055, gamma); - color.g = (color.g <= 0.0404482362771082) ? - color.g / 12.92 : pow((color.g + 0.055) / 1.055, gamma); - color.b = (color.b <= 0.0404482362771082) ? - color.b / 12.92 : pow((color.b + 0.055) / 1.055, gamma); - - return color; -} - -float3 LinearToRGBGamma(float3 color, float gamma) -{ - color = saturate(color); - color.r = (color.r <= 0.00313066844250063) ? - color.r * 12.92 : 1.055 * pow(color.r, 1.0 / gamma) - 0.055; - color.g = (color.g <= 0.00313066844250063) ? - color.g * 12.92 : 1.055 * pow(color.g, 1.0 / gamma) - 0.055; - color.b = (color.b <= 0.00313066844250063) ? - color.b * 12.92 : 1.055 * pow(color.b, 1.0 / gamma) - 0.055; - - return color; -} - -float4 PreGammaPass(float4 color, float2 uv0) -{ - #if (SHADER_MODEL >= 0x400) - color = Texture.Sample(TextureSampler, uv0); - #else - color = tex2D(TextureSampler, uv0); - #endif - - const float GammaConst = 2.233; - color.rgb = RGBGammaToLinear(color.rgb, GammaConst); - color.rgb = LinearToRGBGamma(color.rgb, GammaConst); - color.a = RGBLuminance(color.rgb); - - return color; -} +#endif /*------------------------------------------------------------------------------ [FXAA CODE SECTION] @@ -111,6 +86,8 @@ float4 PreGammaPass(float4 color, float2 uv0) #elif (SHADER_MODEL >= 0x400) #define FXAA_HLSL_4 1 #define FXAA_GATHER4_ALPHA 0 +#elif (FXAA_GLSL_130 == 1) +#define FXAA_GATHER4_ALPHA 1 #else #define FXAA_HLSL_3 1 #define FXAA_GATHER4_ALPHA 0 @@ -138,6 +115,24 @@ struct FxaaTex { SamplerState smpl; Texture2D tex; }; #define FxaaSat(x) saturate(x) #define FxaaTexTop(t, p) tex2Dlod(t, float4(p, 0.0, 0.0)) #define FxaaTexOff(t, p, o, r) tex2Dlod(t, float4(p + (o * r), 0, 0)) + +#elif (FXAA_GLSL_130 == 1) + +#define int2 ivec2 +#define float2 vec2 +#define float3 vec3 +#define float4 vec4 +#define FxaaDiscard discard +#define FxaaSat(x) clamp(x, 0.0, 1.0) +#define FxaaTex sampler2D +#define FxaaTexTop(t, p) textureLod(t, p, 0.0) +#define FxaaTexOff(t, p, o, r) textureLodOffset(t, p, 0.0, o) +#if (FXAA_GATHER4_ALPHA == 1) +// use #extension GL_ARB_gpu_shader5 : enable +#define FxaaTexAlpha4(t, p) textureGather(t, p, 3) +#define FxaaTexOffAlpha4(t, p, o) textureGatherOffset(t, p, o, 3) +#endif + #endif #define FxaaEdgeThreshold 0.063 @@ -156,6 +151,69 @@ struct FxaaTex { SamplerState smpl; Texture2D tex; }; #define FXAA_QUALITY__P11 8.0 #define FXAA_QUALITY__P12 8.0 +/*------------------------------------------------------------------------------ + [GAMMA PREPASS CODE SECTION] +------------------------------------------------------------------------------*/ +float RGBLuminance(float3 color) +{ + const float3 lumCoeff = float3(0.2126729, 0.7151522, 0.0721750); + return dot(color.rgb, lumCoeff); +} + +#if (FXAA_GLSL_130 == 0) +#define PixelSize float2(_rcpFrame.x, _rcpFrame.y) +#endif + + +float3 RGBGammaToLinear(float3 color, float gamma) +{ + color = FxaaSat(color); + color.r = (color.r <= 0.0404482362771082) ? + color.r / 12.92 : pow((color.r + 0.055) / 1.055, gamma); + color.g = (color.g <= 0.0404482362771082) ? + color.g / 12.92 : pow((color.g + 0.055) / 1.055, gamma); + color.b = (color.b <= 0.0404482362771082) ? + color.b / 12.92 : pow((color.b + 0.055) / 1.055, gamma); + + return color; +} + +float3 LinearToRGBGamma(float3 color, float gamma) +{ + color = FxaaSat(color); + color.r = (color.r <= 0.00313066844250063) ? + color.r * 12.92 : 1.055 * pow(color.r, 1.0 / gamma) - 0.055; + color.g = (color.g <= 0.00313066844250063) ? + color.g * 12.92 : 1.055 * pow(color.g, 1.0 / gamma) - 0.055; + color.b = (color.b <= 0.00313066844250063) ? + color.b * 12.92 : 1.055 * pow(color.b, 1.0 / gamma) - 0.055; + + return color; +} + +float4 PreGammaPass(float4 color, float2 uv0) +{ + #if (SHADER_MODEL >= 0x400) + color = Texture.Sample(TextureSampler, uv0); + #elif (FXAA_GLSL_130 == 1) + color = texture(TextureSampler, uv0); + #else + color = tex2D(TextureSampler, uv0); + #endif + + const float GammaConst = 2.233; + color.rgb = RGBGammaToLinear(color.rgb, GammaConst); + color.rgb = LinearToRGBGamma(color.rgb, GammaConst); + color.a = RGBLuminance(color.rgb); + + return color; +} + + +/*------------------------------------------------------------------------------ + [FXAA CODE SECTION] +------------------------------------------------------------------------------*/ + float FxaaLuma(float4 rgba) { rgba.w = RGBLuminance(rgba.xyz); @@ -463,7 +521,11 @@ float4 FxaaPixelShader(float2 pos, FxaaTex tex, float2 fxaaRcpFrame, float fxaaS return float4(FxaaTexTop(tex, posM).xyz, lumaM); } +#if (FXAA_GLSL_130 == 1) +float4 FxaaPass(float4 FxaaColor, float2 uv0) +#else float4 FxaaPass(float4 FxaaColor : COLOR0, float2 uv0 : TEXCOORD0) +#endif { FxaaTex tex; @@ -473,6 +535,13 @@ float4 FxaaPass(float4 FxaaColor : COLOR0, float2 uv0 : TEXCOORD0) Texture.GetDimensions(PixelSize.x, PixelSize.y); FxaaColor = FxaaPixelShader(uv0, tex, 1.0/PixelSize.xy, FxaaSubpixMax, FxaaEdgeThreshold, FxaaEdgeThresholdMin); + + #elif (FXAA_GLSL_130 == 1) + + tex = TextureSampler; + vec2 PixelSize = textureSize(tex, 0); + FxaaColor = FxaaPixelShader(uv0, tex, 1.0/PixelSize.xy, FxaaSubpixMax, FxaaEdgeThreshold, FxaaEdgeThresholdMin); + #else tex = TextureSampler; @@ -485,6 +554,18 @@ float4 FxaaPass(float4 FxaaColor : COLOR0, float2 uv0 : TEXCOORD0) /*------------------------------------------------------------------------------ [MAIN() & COMBINE PASS CODE SECTION] ------------------------------------------------------------------------------*/ +#if (FXAA_GLSL_130 == 1) + +void ps_main() +{ + vec4 color = texture(TextureSampler, PSin.t); + color = PreGammaPass(color, PSin.t); + color = FxaaPass(color, PSin.t); + + SV_Target0 = color; +} + +#else PS_OUTPUT ps_main(VS_OUTPUT input) { @@ -506,4 +587,7 @@ PS_OUTPUT ps_main(VS_OUTPUT input) return output; } + +#endif + #endif diff --git a/plugins/GSdx/res/glsl_source.h b/plugins/GSdx/res/glsl_source.h index f5b682de16..287c963e26 100644 --- a/plugins/GSdx/res/glsl_source.h +++ b/plugins/GSdx/res/glsl_source.h @@ -1523,86 +1523,28 @@ static const char* tfx_glsl = "#endif\n" ; -static const char* old_fxaa_fx = - "#if defined(SHADER_MODEL) || defined(FXAA_GLSL_130) // make safe to include in resource file to enforce dependency\n" +static const char* fxaa_fx = + "#if defined(SHADER_MODEL) || defined(FXAA_GLSL_130)\n" "\n" "#ifndef FXAA_GLSL_130\n" " #define FXAA_GLSL_130 0\n" "#endif\n" "\n" - "#define FXAA_PC 1\n" - "#define FXAA_QUALITY_SUBPIX 0.0\n" - "\n" - "#ifdef SHADER_MODEL\n" - "#if SHADER_MODEL >= 0x400\n" - "\n" - "#if SHADER_MODEL >= 0x500\n" - " #define FXAA_HLSL_5 1\n" - "#else \n" - " #define FXAA_HLSL_4 1\n" - "#endif\n" - "\n" - "Texture2D Texture;\n" - "SamplerState TextureSampler;\n" - "\n" - "cbuffer cb0\n" - "{\n" - " float4 _rcpFrame;\n" - " float4 _rcpFrameOpt;\n" - "};\n" - "\n" - "struct PS_INPUT\n" - "{\n" - " float4 p : SV_Position;\n" - " float2 t : TEXCOORD0;\n" - "};\n" - "\n" - "struct PS_OUTPUT\n" - "{\n" - " float4 c : SV_Target0;\n" - "};\n" - "\n" - "#elif SHADER_MODEL <= 0x300\n" - "\n" - "#define FXAA_HLSL_3 1\n" - "\n" - "sampler Texture : register(s0);\n" - "\n" - "float4 _rcpFrame : register(c0);\n" - "float4 _rcpFrameOpt : register(c1);\n" - "\n" - "struct PS_INPUT\n" - "{\n" - "#if SHADER_MODEL < 0x300\n" - " float4 p : TEXCOORD1;\n" - "#else\n" - " float4 p : VPOS;\n" - "#endif\n" - " float2 t : TEXCOORD0;\n" - "};\n" - "\n" - "struct PS_OUTPUT\n" - "{\n" - " float4 c : COLOR;\n" - "};\n" - "\n" - "#endif\n" - "#endif\n" - "\n" + "#define UHQ_FXAA 1 //High Quality Fast Approximate Anti Aliasing. Adapted for GSdx from Timothy Lottes FXAA 3.11.\n" + "#define FxaaSubpixMax 0.0 //[0.00 to 1.00] Amount of subpixel aliasing removal. 0.00: Edge only antialiasing (no blurring)\n" + "#define FxaaEarlyExit 1 //[0 or 1] Use Fxaa early exit pathing. When disabled, the entire scene is antialiased(FSAA). 0 is off, 1 is on.\n" "\n" + "/*------------------------------------------------------------------------------\n" + " [GLOBALS|FUNCTIONS]\n" + "------------------------------------------------------------------------------*/\n" "#if (FXAA_GLSL_130 == 1)\n" + "\n" "struct vertex_basic\n" "{\n" " vec4 p;\n" " vec2 t;\n" "};\n" "\n" - "layout(std140, binding = 13) uniform cb13\n" - "{\n" - " vec4 _rcpFrame;\n" - " vec4 _rcpFrameOpt;\n" - "};\n" - "\n" "#ifdef ENABLE_BINDLESS_TEX\n" "layout(bindless_sampler, location = 0) uniform sampler2D TextureSampler;\n" "#else\n" @@ -1615,1142 +1557,563 @@ static const char* old_fxaa_fx = " vec2 t;\n" "} PSin;\n" "\n" - "#define PSin_p (PSin.p)\n" - "#define PSin_t (PSin.t)\n" - "\n" "layout(location = 0) out vec4 SV_Target0;\n" "\n" + "#else\n" + "\n" + "#if (SHADER_MODEL >= 0x400)\n" + "Texture2D Texture : register(t0);\n" + "SamplerState TextureSampler : register(s0);\n" + "#else\n" + "texture2D Texture : register(t0);\n" + "sampler2D TextureSampler : register(s0);\n" + "#define SamplerState sampler2D\n" "#endif\n" "\n" - "/*============================================================================\n" - "\n" - "\n" - " NVIDIA FXAA 3.10 by TIMOTHY LOTTES\n" - "\n" - "\n" - "------------------------------------------------------------------------------\n" - "COPYRIGHT (C) 2010, 2011 NVIDIA CORPORATION. ALL RIGHTS RESERVED.\n" - "------------------------------------------------------------------------------\n" - "TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED\n" - "*AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS\n" - "OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF\n" - "MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL NVIDIA\n" - "OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR\n" - "CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR\n" - "LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION,\n" - "OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR INABILITY TO USE\n" - "THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH\n" - "DAMAGES.\n" - "\n" - "------------------------------------------------------------------------------\n" - " INTEGRATION CHECKLIST\n" - "------------------------------------------------------------------------------\n" - "(1.)\n" - "In the shader source,\n" - "setup defines for the desired configuration.\n" - "Example,\n" - "\n" - " #define FXAA_PC 1\n" - " #define FXAA_HLSL_3 1\n" - " #define FXAA_QUALITY_PRESET 12\n" - " #define FXAA_QUALITY_EDGE_THRESHOLD (1.0/6.0)\n" - " #define FXAA_QUALITY_EDGE_THRESHOLD_MIN (1.0/12.0)\n" - "\n" - "(2.)\n" - "Then include this file,\n" - "\n" - " #include \"Fxaa3.h\"\n" - "\n" - "(3.)\n" - "Then call the FXAA pixel shader from within your desired shader,\n" - "\n" - " return FxaaPixelShader(pos, posPos, tex, rcpFrame, rcpFrameOpt);\n" - "\n" - "(4.)\n" - "Insure pass prior to FXAA outputs RGBL.\n" - "See next section.\n" - "\n" - "(5.)\n" - "Setup engine to provide \"rcpFrame\" and \"rcpFrameOpt\" constants.\n" - "Not using constants will result in a performance loss.\n" - "\n" - " // {x_} = 1.0/screenWidthInPixels\n" - " // {_y} = 1.0/screenHeightInPixels\n" - " float2 rcpFrame\n" - "\n" - " // This must be from a constant/uniform.\n" - " // {x___} = 2.0/screenWidthInPixels\n" - " // {_y__} = 2.0/screenHeightInPixels\n" - " // {__z_} = 0.5/screenWidthInPixels\n" - " // {___w} = 0.5/screenHeightInPixels\n" - " float4 rcpFrameOpt\n" - "\n" - "(5.a.) \n" - "Optionally change to this for sharper FXAA Console,\n" - "\n" - " // This must be from a constant/uniform.\n" - " // {x___} = 2.0/screenWidthInPixels\n" - " // {_y__} = 2.0/screenHeightInPixels\n" - " // {__z_} = 0.333/screenWidthInPixels\n" - " // {___w} = 0.333/screenHeightInPixels\n" - " float4 rcpFrameOpt\n" - "\n" - "(6.)\n" - "Have FXAA vertex shader run as a full screen triangle,\n" - "and output \"pos\" and \"posPos\" such that inputs in the pixel shader provide,\n" - "\n" - " // {xy} = center of pixel\n" - " float2 pos,\n" - "\n" - " // {xy__} = upper left of pixel\n" - " // {__zw} = lower right of pixel\n" - " float4 posPos,\n" - "\n" - "(7.)\n" - "Insure the texture sampler used by FXAA is set to bilinear filtering.\n" - "\n" - "\n" - "------------------------------------------------------------------------------\n" - " INTEGRATION - RGBL AND COLORSPACE\n" - "------------------------------------------------------------------------------\n" - "FXAA3 requires RGBL as input.\n" - "\n" - "RGB should be LDR (low dynamic range).\n" - "Specifically do FXAA after tonemapping.\n" - "\n" - "RGB data as returned by a texture fetch can be linear or non-linear.\n" - "Note an \"sRGB format\" texture counts as linear,\n" - "because the result of a texture fetch is linear data.\n" - "Regular \"RGBA8\" textures in the sRGB colorspace are non-linear.\n" - "\n" - "Luma must be stored in the alpha channel prior to running FXAA.\n" - "This luma should be in a perceptual space (could be gamma 2.0).\n" - "Example pass before FXAA where output is gamma 2.0 encoded,\n" - "\n" - " color.rgb = ToneMap(color.rgb); // linear color output\n" - " color.rgb = sqrt(color.rgb); // gamma 2.0 color output\n" - " return color;\n" - "\n" - "To use FXAA,\n" - "\n" - " color.rgb = ToneMap(color.rgb); // linear color output\n" - " color.rgb = sqrt(color.rgb); // gamma 2.0 color output\n" - " color.a = dot(color.rgb, float3(0.299, 0.587, 0.114)); // compute luma\n" - " return color;\n" - "\n" - "Another example where output is linear encoded,\n" - "say for instance writing to an sRGB formated render target,\n" - "where the render target does the conversion back to sRGB after blending,\n" - "\n" - " color.rgb = ToneMap(color.rgb); // linear color output\n" - " return color;\n" - "\n" - "To use FXAA,\n" - "\n" - " color.rgb = ToneMap(color.rgb); // linear color output\n" - " color.a = sqrt(dot(color.rgb, float3(0.299, 0.587, 0.114))); // compute luma\n" - " return color;\n" - "\n" - "Getting luma correct is required for the algorithm to work correctly.\n" - "\n" - "\n" - "------------------------------------------------------------------------------\n" - " BEING LINEARLY CORRECT?\n" - "------------------------------------------------------------------------------\n" - "Applying FXAA to a framebuffer with linear RGB color will look worse.\n" - "This is very counter intuitive, but happends to be true in this case.\n" - "The reason is because dithering artifacts will be more visiable \n" - "in a linear colorspace.\n" - "\n" - "\n" - "------------------------------------------------------------------------------\n" - " COMPLEX INTEGRATION\n" - "------------------------------------------------------------------------------\n" - "Q. What if the engine is blending into RGB before wanting to run FXAA?\n" - "\n" - "A. In the last opaque pass prior to FXAA,\n" - " have the pass write out luma into alpha.\n" - " Then blend into RGB only.\n" - " FXAA should be able to run ok\n" - " assuming the blending pass did not any add aliasing.\n" - " This should be the common case for particles and common blending passes.\n" - "\n" - "============================================================================*/\n" - "\n" - "/*============================================================================\n" - "\n" - " INTEGRATION KNOBS\n" - "\n" - "============================================================================*/\n" - "//\n" - "// FXAA_PS3 and FXAA_360 choose the console algorithm (FXAA3 CONSOLE).\n" - "// FXAA_360_OPT is a prototype for the new optimized 360 version.\n" - "//\n" - "// 1 = Use API.\n" - "// 0 = Don't use API.\n" - "//\n" - "/*--------------------------------------------------------------------------*/\n" - "#ifndef FXAA_PS3\n" - " #define FXAA_PS3 0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#ifndef FXAA_360\n" - " #define FXAA_360 0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#ifndef FXAA_360_OPT\n" - " #define FXAA_360_OPT 0\n" - "#endif\n" - "/*==========================================================================*/\n" - "#ifndef FXAA_PC\n" - " //\n" - " // FXAA Quality\n" - " // The high quality PC algorithm.\n" - " //\n" - " #define FXAA_PC 0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#ifndef FXAA_PC_CONSOLE\n" - " //\n" - " // The console algorithm for PC is included\n" - " // for developers targeting really low spec machines.\n" - " //\n" - " #define FXAA_PC_CONSOLE 0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#ifndef FXAA_GLSL_120\n" - " #define FXAA_GLSL_120 0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#ifndef FXAA_GLSL_130\n" - " #define FXAA_GLSL_130 0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#ifndef FXAA_HLSL_3\n" - " #define FXAA_HLSL_3 0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#ifndef FXAA_HLSL_4\n" - " #define FXAA_HLSL_4 0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#ifndef FXAA_HLSL_5\n" - " #define FXAA_HLSL_5 0\n" - "#endif\n" - "/*==========================================================================*/\n" - "#ifndef FXAA_EARLY_EXIT\n" - " //\n" - " // Controls algorithm's early exit path.\n" - " // On PS3 turning this on adds 2 cycles to the shader.\n" - " // On 360 turning this off adds 10ths of a millisecond to the shader.\n" - " // Turning this off on console will result in a more blurry image.\n" - " // So this defaults to on.\n" - " //\n" - " // 1 = On.\n" - " // 0 = Off.\n" - " //\n" - " #define FXAA_EARLY_EXIT 1\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#ifndef FXAA_DISCARD\n" - " //\n" - " // Only valid for PC OpenGL currently.\n" - " //\n" - " // 1 = Use discard on pixels which don't need AA.\n" - " // For APIs which enable concurrent TEX+ROP from same surface.\n" - " // 0 = Return unchanged color on pixels which don't need AA.\n" - " //\n" - " #define FXAA_DISCARD 0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#ifndef FXAA_FAST_PIXEL_OFFSET\n" - " //\n" - " // Used for GLSL 120 only.\n" - " //\n" - " // 1 = GL API supports fast pixel offsets\n" - " // 0 = do not use fast pixel offsets\n" - " //\n" - " #ifdef GL_EXT_gpu_shader4\n" - " #define FXAA_FAST_PIXEL_OFFSET 1\n" - " #endif\n" - " #ifdef GL_NV_gpu_shader5\n" - " #define FXAA_FAST_PIXEL_OFFSET 1\n" - " #endif\n" - " #ifdef GL_ARB_gpu_shader5\n" - " #define FXAA_FAST_PIXEL_OFFSET 1\n" - " #endif\n" - " #ifndef FXAA_FAST_PIXEL_OFFSET\n" - " #define FXAA_FAST_PIXEL_OFFSET 0\n" - " #endif\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#ifndef FXAA_GATHER4_ALPHA\n" - " //\n" - " // 1 = API supports gather4 on alpha channel.\n" - " // 0 = API does not support gather4 on alpha channel.\n" - " //\n" - " #if (FXAA_HLSL_5 == 1)\n" - " #define FXAA_GATHER4_ALPHA 1\n" - " #endif\n" - " #ifdef GL_ARB_gpu_shader5\n" - " #define FXAA_GATHER4_ALPHA 1\n" - " #endif\n" - " #ifdef GL_NV_gpu_shader5\n" - " #define FXAA_GATHER4_ALPHA 1\n" - " #endif\n" - " #ifndef FXAA_GATHER4_ALPHA\n" - " #define FXAA_GATHER4_ALPHA 0\n" - " #endif\n" - "#endif\n" - "\n" - "/*============================================================================\n" - " FXAA CONSOLE - TUNING KNOBS\n" - "============================================================================*/\n" - "#ifndef FXAA_CONSOLE_EDGE_SHARPNESS\n" - " //\n" - " // Consoles the sharpness of edges.\n" - " //\n" - " // Due to the PS3 being ALU bound,\n" - " // there are only two safe values here: 4 and 8.\n" - " // These options use the shaders ability to a free *|/ by 4|8.\n" - " //\n" - " // 8.0 is sharper\n" - " // 4.0 is softer\n" - " // 2.0 is really soft (good for vector graphics inputs)\n" - " //\n" - " #if 1\n" - " #define FXAA_CONSOLE_EDGE_SHARPNESS 8.0\n" - " #endif\n" - " #if 0\n" - " #define FXAA_CONSOLE_EDGE_SHARPNESS 4.0\n" - " #endif\n" - " #if 0\n" - " #define FXAA_CONSOLE_EDGE_SHARPNESS 2.0\n" - " #endif\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#ifndef FXAA_CONSOLE_EDGE_THRESHOLD\n" - " //\n" - " // The minimum amount of local contrast required to apply algorithm.\n" - " // The console setting has a different mapping than the quality setting.\n" - " //\n" - " // This only applies when FXAA_EARLY_EXIT is 1.\n" - " //\n" - " // Due to the PS3 being ALU bound,\n" - " // there are only two safe values here: 0.25 and 0.125.\n" - " // These options use the shaders ability to a free *|/ by 4|8.\n" - " //\n" - " // 0.125 leaves less aliasing, but is softer\n" - " // 0.25 leaves more aliasing, and is sharper\n" - " //\n" - " #if 1\n" - " #define FXAA_CONSOLE_EDGE_THRESHOLD 0.125\n" - " #else\n" - " #define FXAA_CONSOLE_EDGE_THRESHOLD 0.25\n" - " #endif\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#ifndef FXAA_CONSOLE_EDGE_THRESHOLD_MIN\n" - " //\n" - " // Trims the algorithm from processing darks.\n" - " // The console setting has a different mapping than the quality setting.\n" - " //\n" - " // This only applies when FXAA_EARLY_EXIT is 1.\n" - " //\n" - " // This does not apply to PS3.\n" - " // PS3 was simplified to avoid more shader instructions.\n" - " //\n" - " #define FXAA_CONSOLE_EDGE_THRESHOLD_MIN 0.05\n" - "#endif\n" - "\n" - "/*============================================================================\n" - " FXAA QUALITY - TUNING KNOBS\n" - "============================================================================*/\n" - "#ifndef FXAA_QUALITY_EDGE_THRESHOLD\n" - " //\n" - " // The minimum amount of local contrast required to apply algorithm.\n" - " //\n" - " // 1/3 - too little\n" - " // 1/4 - low quality\n" - " // 1/6 - default\n" - " // 1/8 - high quality (default)\n" - " // 1/16 - overkill\n" - " //\n" - " #define FXAA_QUALITY_EDGE_THRESHOLD (1.0/6.0)\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#ifndef FXAA_QUALITY_EDGE_THRESHOLD_MIN\n" - " //\n" - " // Trims the algorithm from processing darks.\n" - " //\n" - " // 1/32 - visible limit\n" - " // 1/16 - high quality\n" - " // 1/12 - upper limit (default, the start of visible unfiltered edges)\n" - " //\n" - " #define FXAA_QUALITY_EDGE_THRESHOLD_MIN (1.0/12.0)\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#ifndef FXAA_QUALITY_SUBPIX\n" - " //\n" - " // Choose the amount of sub-pixel aliasing removal.\n" - " //\n" - " // 1 - upper limit (softer)\n" - " // 3/4 - default amount of filtering\n" - " // 1/2 - lower limit (sharper, less sub-pixel aliasing removal)\n" - " //\n" - " #define FXAA_QUALITY_SUBPIX (3.0/4.0)\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#ifndef FXAA_QUALITY_PRESET\n" - " //\n" - " // Choose the quality preset.\n" - " // \n" - " // OPTIONS\n" - " // -----------------------------------------------------------------------\n" - " // 10 to 15 - default medium dither (10=fastest, 15=highest quality)\n" - " // 20 to 29 - less dither, more expensive (20=fastest, 29=highest quality)\n" - " // 39 - no dither, very expensive \n" - " //\n" - " // NOTES\n" - " // -----------------------------------------------------------------------\n" - " // 12 = slightly faster then FXAA 3.9 and higher edge quality (default)\n" - " // 13 = about same speed as FXAA 3.9 and better than 12\n" - " // 23 = closest to FXAA 3.9 visually and performance wise\n" - " // _ = the lowest digit is directly related to performance\n" - " // _ = the highest digit is directly related to style\n" - " // \n" - " #define FXAA_QUALITY_PRESET 12\n" - "#endif\n" - "\n" - "\n" - "/*============================================================================\n" - "\n" - " FXAA QUALITY - PRESETS\n" - "\n" - "============================================================================*/\n" - "\n" - "/*============================================================================\n" - " FXAA QUALITY - MEDIUM DITHER PRESETS\n" - "============================================================================*/\n" - "#if (FXAA_QUALITY_PRESET == 10)\n" - " #define FXAA_QUALITY_PS 3\n" - " #define FXAA_QUALITY_P0 1.5\n" - " #define FXAA_QUALITY_P1 3.0\n" - " #define FXAA_QUALITY_P2 12.0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#if (FXAA_QUALITY_PRESET == 11)\n" - " #define FXAA_QUALITY_PS 4\n" - " #define FXAA_QUALITY_P0 1.0\n" - " #define FXAA_QUALITY_P1 1.5\n" - " #define FXAA_QUALITY_P2 3.0\n" - " #define FXAA_QUALITY_P3 12.0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#if (FXAA_QUALITY_PRESET == 12)\n" - " #define FXAA_QUALITY_PS 5\n" - " #define FXAA_QUALITY_P0 1.0\n" - " #define FXAA_QUALITY_P1 1.5\n" - " #define FXAA_QUALITY_P2 2.0\n" - " #define FXAA_QUALITY_P3 4.0\n" - " #define FXAA_QUALITY_P4 12.0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#if (FXAA_QUALITY_PRESET == 13)\n" - " #define FXAA_QUALITY_PS 6\n" - " #define FXAA_QUALITY_P0 1.0\n" - " #define FXAA_QUALITY_P1 1.5\n" - " #define FXAA_QUALITY_P2 2.0\n" - " #define FXAA_QUALITY_P3 2.0\n" - " #define FXAA_QUALITY_P4 4.0\n" - " #define FXAA_QUALITY_P5 12.0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#if (FXAA_QUALITY_PRESET == 14)\n" - " #define FXAA_QUALITY_PS 7\n" - " #define FXAA_QUALITY_P0 1.0\n" - " #define FXAA_QUALITY_P1 1.5\n" - " #define FXAA_QUALITY_P2 2.0\n" - " #define FXAA_QUALITY_P3 2.0\n" - " #define FXAA_QUALITY_P4 2.0\n" - " #define FXAA_QUALITY_P5 4.0\n" - " #define FXAA_QUALITY_P6 12.0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#if (FXAA_QUALITY_PRESET == 15)\n" - " #define FXAA_QUALITY_PS 8\n" - " #define FXAA_QUALITY_P0 1.0\n" - " #define FXAA_QUALITY_P1 1.5\n" - " #define FXAA_QUALITY_P2 2.0\n" - " #define FXAA_QUALITY_P3 2.0\n" - " #define FXAA_QUALITY_P4 2.0\n" - " #define FXAA_QUALITY_P5 2.0\n" - " #define FXAA_QUALITY_P6 4.0\n" - " #define FXAA_QUALITY_P7 12.0\n" - "#endif\n" - "\n" - "/*============================================================================\n" - " FXAA QUALITY - LOW DITHER PRESETS\n" - "============================================================================*/\n" - "#if (FXAA_QUALITY_PRESET == 20)\n" - " #define FXAA_QUALITY_PS 3\n" - " #define FXAA_QUALITY_P0 1.5\n" - " #define FXAA_QUALITY_P1 2.0\n" - " #define FXAA_QUALITY_P2 8.0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#if (FXAA_QUALITY_PRESET == 21)\n" - " #define FXAA_QUALITY_PS 4\n" - " #define FXAA_QUALITY_P0 1.0\n" - " #define FXAA_QUALITY_P1 1.5\n" - " #define FXAA_QUALITY_P2 2.0\n" - " #define FXAA_QUALITY_P3 8.0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#if (FXAA_QUALITY_PRESET == 22)\n" - " #define FXAA_QUALITY_PS 5\n" - " #define FXAA_QUALITY_P0 1.0\n" - " #define FXAA_QUALITY_P1 1.5\n" - " #define FXAA_QUALITY_P2 2.0\n" - " #define FXAA_QUALITY_P3 2.0\n" - " #define FXAA_QUALITY_P4 8.0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#if (FXAA_QUALITY_PRESET == 23)\n" - " #define FXAA_QUALITY_PS 6\n" - " #define FXAA_QUALITY_P0 1.0\n" - " #define FXAA_QUALITY_P1 1.5\n" - " #define FXAA_QUALITY_P2 2.0\n" - " #define FXAA_QUALITY_P3 2.0\n" - " #define FXAA_QUALITY_P4 2.0\n" - " #define FXAA_QUALITY_P5 8.0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#if (FXAA_QUALITY_PRESET == 24)\n" - " #define FXAA_QUALITY_PS 7\n" - " #define FXAA_QUALITY_P0 1.0\n" - " #define FXAA_QUALITY_P1 1.5\n" - " #define FXAA_QUALITY_P2 2.0\n" - " #define FXAA_QUALITY_P3 2.0\n" - " #define FXAA_QUALITY_P4 2.0\n" - " #define FXAA_QUALITY_P5 3.0\n" - " #define FXAA_QUALITY_P6 8.0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#if (FXAA_QUALITY_PRESET == 25)\n" - " #define FXAA_QUALITY_PS 8\n" - " #define FXAA_QUALITY_P0 1.0\n" - " #define FXAA_QUALITY_P1 1.5\n" - " #define FXAA_QUALITY_P2 2.0\n" - " #define FXAA_QUALITY_P3 2.0\n" - " #define FXAA_QUALITY_P4 2.0\n" - " #define FXAA_QUALITY_P5 2.0\n" - " #define FXAA_QUALITY_P6 4.0\n" - " #define FXAA_QUALITY_P7 8.0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#if (FXAA_QUALITY_PRESET == 26)\n" - " #define FXAA_QUALITY_PS 9\n" - " #define FXAA_QUALITY_P0 1.0\n" - " #define FXAA_QUALITY_P1 1.5\n" - " #define FXAA_QUALITY_P2 2.0\n" - " #define FXAA_QUALITY_P3 2.0\n" - " #define FXAA_QUALITY_P4 2.0\n" - " #define FXAA_QUALITY_P5 2.0\n" - " #define FXAA_QUALITY_P6 2.0\n" - " #define FXAA_QUALITY_P7 4.0\n" - " #define FXAA_QUALITY_P8 8.0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#if (FXAA_QUALITY_PRESET == 27)\n" - " #define FXAA_QUALITY_PS 10\n" - " #define FXAA_QUALITY_P0 1.0\n" - " #define FXAA_QUALITY_P1 1.5\n" - " #define FXAA_QUALITY_P2 2.0\n" - " #define FXAA_QUALITY_P3 2.0\n" - " #define FXAA_QUALITY_P4 2.0\n" - " #define FXAA_QUALITY_P5 2.0\n" - " #define FXAA_QUALITY_P6 2.0\n" - " #define FXAA_QUALITY_P7 2.0\n" - " #define FXAA_QUALITY_P8 4.0\n" - " #define FXAA_QUALITY_P9 8.0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#if (FXAA_QUALITY_PRESET == 28)\n" - " #define FXAA_QUALITY_PS 11\n" - " #define FXAA_QUALITY_P0 1.0\n" - " #define FXAA_QUALITY_P1 1.5\n" - " #define FXAA_QUALITY_P2 2.0\n" - " #define FXAA_QUALITY_P3 2.0\n" - " #define FXAA_QUALITY_P4 2.0\n" - " #define FXAA_QUALITY_P5 2.0\n" - " #define FXAA_QUALITY_P6 2.0\n" - " #define FXAA_QUALITY_P7 2.0\n" - " #define FXAA_QUALITY_P8 2.0\n" - " #define FXAA_QUALITY_P9 4.0\n" - " #define FXAA_QUALITY_P10 8.0\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#if (FXAA_QUALITY_PRESET == 29)\n" - " #define FXAA_QUALITY_PS 12\n" - " #define FXAA_QUALITY_P0 1.0\n" - " #define FXAA_QUALITY_P1 1.5\n" - " #define FXAA_QUALITY_P2 2.0\n" - " #define FXAA_QUALITY_P3 2.0\n" - " #define FXAA_QUALITY_P4 2.0\n" - " #define FXAA_QUALITY_P5 2.0\n" - " #define FXAA_QUALITY_P6 2.0\n" - " #define FXAA_QUALITY_P7 2.0\n" - " #define FXAA_QUALITY_P8 2.0\n" - " #define FXAA_QUALITY_P9 2.0\n" - " #define FXAA_QUALITY_P10 4.0\n" - " #define FXAA_QUALITY_P11 8.0\n" - "#endif\n" - "\n" - "/*============================================================================\n" - " FXAA QUALITY - EXTREME QUALITY\n" - "============================================================================*/\n" - "#if (FXAA_QUALITY_PRESET == 39)\n" - " #define FXAA_QUALITY_PS 12\n" - " #define FXAA_QUALITY_P0 1.0\n" - " #define FXAA_QUALITY_P1 1.0\n" - " #define FXAA_QUALITY_P2 1.0\n" - " #define FXAA_QUALITY_P3 1.0\n" - " #define FXAA_QUALITY_P4 1.0\n" - " #define FXAA_QUALITY_P5 1.5\n" - " #define FXAA_QUALITY_P6 2.0\n" - " #define FXAA_QUALITY_P7 2.0\n" - " #define FXAA_QUALITY_P8 2.0\n" - " #define FXAA_QUALITY_P9 2.0\n" - " #define FXAA_QUALITY_P10 4.0\n" - " #define FXAA_QUALITY_P11 8.0\n" - "#endif\n" - "\n" - "\n" - "\n" - "/*============================================================================\n" - "\n" - " API PORTING\n" - "\n" - "============================================================================*/\n" - "#if (FXAA_GLSL_120 == 1)\n" - " // Requires,\n" - " // #version 120\n" - " // And at least,\n" - " // #extension GL_EXT_gpu_shader4 : enable\n" - " // (or set FXAA_FAST_PIXEL_OFFSET 1 to work like DX9)\n" - " #define half float\n" - " #define half2 vec2\n" - " #define half3 vec3\n" - " #define half4 vec4\n" - " #define int2 ivec2\n" - " #define float2 vec2\n" - " #define float3 vec3\n" - " #define float4 vec4\n" - " #define FxaaInt2 ivec2\n" - " #define FxaaFloat2 vec2\n" - " #define FxaaFloat3 vec3\n" - " #define FxaaFloat4 vec4\n" - " #define FxaaDiscard discard\n" - " #define FxaaDot3(a, b) dot(a, b)\n" - " #define FxaaSat(x) clamp(x, 0.0, 1.0)\n" - " #define FxaaLerp(x,y,s) mix(x,y,s)\n" - " #define FxaaTex sampler2D\n" - " #define FxaaTexTop(t, p) texture2DLod(t, p, 0.0)\n" - " #if (FXAA_FAST_PIXEL_OFFSET == 1)\n" - " #define FxaaTexOff(t, p, o, r) texture2DLodOffset(t, p, 0.0, o)\n" - " #else\n" - " #define FxaaTexOff(t, p, o, r) texture2DLod(t, p + (o * r), 0.0)\n" - " #endif\n" - " #if (FXAA_GATHER4_ALPHA == 1)\n" - " // use #extension GL_ARB_gpu_shader5 : enable\n" - " #define FxaaTexAlpha4(t, p, r) textureGather(t, p, 3)\n" - " #define FxaaTexOffAlpha4(t, p, o, r) textureGatherOffset(t, p, o, 3)\n" - " #endif\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#if (FXAA_GLSL_130 == 1)\n" - " // Requires \"#version 130\" or better\n" - " #define half float\n" - " #define half2 vec2\n" - " #define half3 vec3\n" - " #define half4 vec4\n" - " #define int2 ivec2\n" - " #define float2 vec2\n" - " #define float3 vec3\n" - " #define float4 vec4\n" - " #define FxaaInt2 ivec2\n" - " #define FxaaFloat2 vec2\n" - " #define FxaaFloat3 vec3\n" - " #define FxaaFloat4 vec4\n" - " #define FxaaDiscard discard\n" - " #define FxaaDot3(a, b) dot(a, b)\n" - " #define FxaaSat(x) clamp(x, 0.0, 1.0)\n" - " #define FxaaLerp(x,y,s) mix(x,y,s)\n" - " #define FxaaTex sampler2D\n" - " #define FxaaTexTop(t, p) textureLod(t, p, 0.0)\n" - " #define FxaaTexOff(t, p, o, r) textureLodOffset(t, p, 0.0, o)\n" - " #if (FXAA_GATHER4_ALPHA == 1)\n" - " // use #extension GL_ARB_gpu_shader5 : enable\n" - " #define FxaaTexAlpha4(t, p, r) textureGather(t, p, 3)\n" - " #define FxaaTexOffAlpha4(t, p, o, r) textureGatherOffset(t, p, o, 3)\n" - " #endif\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#if (FXAA_HLSL_3 == 1) || (FXAA_360 == 1)\n" - " #define int2 float2\n" - " #define FxaaInt2 float2\n" - " #define FxaaFloat2 float2\n" - " #define FxaaFloat3 float3\n" - " #define FxaaFloat4 float4\n" - " #define FxaaDiscard clip(-1)\n" - " #define FxaaDot3(a, b) dot(a, b)\n" - " #define FxaaSat(x) saturate(x)\n" - " #define FxaaLerp(x,y,s) lerp(x,y,s)\n" - " #define FxaaTex sampler2D\n" - " #define FxaaTexTop(t, p) tex2Dlod(t, float4(p, 0.0, 0.0))\n" - " #define FxaaTexOff(t, p, o, r) tex2Dlod(t, float4(p + (o * r), 0, 0))\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#if (FXAA_HLSL_4 == 1)\n" - " #define FxaaInt2 int2\n" - " #define FxaaFloat2 float2\n" - " #define FxaaFloat3 float3\n" - " #define FxaaFloat4 float4\n" - " #define FxaaDiscard clip(-1)\n" - " #define FxaaDot3(a, b) dot(a, b)\n" - " #define FxaaSat(x) saturate(x)\n" - " #define FxaaLerp(x,y,s) lerp(x,y,s)\n" - " struct FxaaTex { SamplerState smpl; Texture2D tex; };\n" - " #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)\n" - " #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)\n" - "#endif\n" - "/*--------------------------------------------------------------------------*/\n" - "#if (FXAA_HLSL_5 == 1)\n" - " #define FxaaInt2 int2\n" - " #define FxaaFloat2 float2\n" - " #define FxaaFloat3 float3\n" - " #define FxaaFloat4 float4\n" - " #define FxaaDiscard clip(-1)\n" - " #define FxaaDot3(a, b) dot(a, b)\n" - " #define FxaaSat(x) saturate(x)\n" - " #define FxaaLerp(x,y,s) lerp(x,y,s)\n" - " struct FxaaTex { SamplerState smpl; Texture2D tex; };\n" - " #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)\n" - " #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)\n" - " #define FxaaTexAlpha4(t, p, r) t.tex.GatherAlpha(t.smpl, p)\n" - " #define FxaaTexOffAlpha4(t, p, o, r) t.tex.GatherAlpha(t.smpl, p, o)\n" - "#endif\n" - "\n" - "\n" - "\n" - "/*============================================================================\n" - "\n" - " FXAA3 QUALITY - PC\n" - "\n" - "============================================================================*/\n" - "#if (FXAA_PC == 1)\n" - "/*--------------------------------------------------------------------------*/\n" - "float4 FxaaPixelShader(\n" - " // {xy} = center of pixel\n" - " float2 pos,\n" - " // {xyzw} = not used on FXAA3 Quality\n" - " float4 posPos,\n" - " // {rgb_} = color in linear or perceptual color space\n" - " // {___a} = luma in perceptual color space (not linear)\n" - " FxaaTex tex,\n" - " // This must be from a constant/uniform.\n" - " // {x_} = 1.0/screenWidthInPixels\n" - " // {_y} = 1.0/screenHeightInPixels\n" - " float2 rcpFrame,\n" - " // {xyzw} = not used on FXAA3 Quality\n" - " float4 rcpFrameOpt\n" - ") {\n" - "/*--------------------------------------------------------------------------*/\n" - " float2 posM;\n" - " posM.x = pos.x;\n" - " posM.y = pos.y;\n" - " #if (FXAA_GATHER4_ALPHA == 1)\n" - " #if (FXAA_DISCARD == 0)\n" - " float4 rgbyM = FxaaTexTop(tex, posM);\n" - " #define lumaM rgbyM.w\n" - " #endif\n" - " float4 luma4A = FxaaTexAlpha4(tex, posM, rcpFrame.xy);\n" - " float4 luma4B = FxaaTexOffAlpha4(tex, posM, FxaaInt2(-1, -1), rcpFrame.xy);\n" - " #if (FXAA_DISCARD == 1)\n" - " #define lumaM luma4A.w\n" - " #endif\n" - " #define lumaE luma4A.z\n" - " #define lumaS luma4A.x\n" - " #define lumaSE luma4A.y\n" - " #define lumaNW luma4B.w\n" - " #define lumaN luma4B.z\n" - " #define lumaW luma4B.x\n" - " #else\n" - " float4 rgbyM = FxaaTexTop(tex, posM);\n" - " #define lumaM rgbyM.w\n" - " float lumaS = FxaaTexOff(tex, posM, FxaaInt2( 0, 1), rcpFrame.xy).w;\n" - " float lumaE = FxaaTexOff(tex, posM, FxaaInt2( 1, 0), rcpFrame.xy).w;\n" - " float lumaN = FxaaTexOff(tex, posM, FxaaInt2( 0,-1), rcpFrame.xy).w;\n" - " float lumaW = FxaaTexOff(tex, posM, FxaaInt2(-1, 0), rcpFrame.xy).w;\n" - " #endif\n" - "/*--------------------------------------------------------------------------*/\n" - " float maxSM = max(lumaS, lumaM);\n" - " float minSM = min(lumaS, lumaM);\n" - " float maxESM = max(lumaE, maxSM);\n" - " float minESM = min(lumaE, minSM);\n" - " float maxWN = max(lumaN, lumaW);\n" - " float minWN = min(lumaN, lumaW);\n" - " float rangeMax = max(maxWN, maxESM);\n" - " float rangeMin = min(minWN, minESM);\n" - " float rangeMaxScaled = rangeMax * FXAA_QUALITY_EDGE_THRESHOLD;\n" - " float range = rangeMax - rangeMin;\n" - " float rangeMaxClamped = max(FXAA_QUALITY_EDGE_THRESHOLD_MIN, rangeMaxScaled);\n" - " bool earlyExit = range < rangeMaxClamped;\n" - "/*--------------------------------------------------------------------------*/\n" - " if(earlyExit)\n" - " #if (FXAA_DISCARD == 1)\n" - " FxaaDiscard;\n" - " #else\n" - " return rgbyM;\n" - " #endif\n" - "/*--------------------------------------------------------------------------*/\n" - " #if (FXAA_GATHER4_ALPHA == 0)\n" - " float lumaNW = FxaaTexOff(tex, posM, FxaaInt2(-1,-1), rcpFrame.xy).w;\n" - " float lumaSE = FxaaTexOff(tex, posM, FxaaInt2( 1, 1), rcpFrame.xy).w;\n" - " float lumaNE = FxaaTexOff(tex, posM, FxaaInt2( 1,-1), rcpFrame.xy).w;\n" - " float lumaSW = FxaaTexOff(tex, posM, FxaaInt2(-1, 1), rcpFrame.xy).w;\n" - " #else\n" - " float lumaNE = FxaaTexOff(tex, posM, FxaaInt2(1, -1), rcpFrame.xy).w;\n" - " float lumaSW = FxaaTexOff(tex, posM, FxaaInt2(-1, 1), rcpFrame.xy).w;\n" - " #endif\n" - "/*--------------------------------------------------------------------------*/\n" - " float lumaNS = lumaN + lumaS;\n" - " float lumaWE = lumaW + lumaE;\n" - " float subpixRcpRange = 1.0/range;\n" - " float subpixNSWE = lumaNS + lumaWE;\n" - " float edgeHorz1 = (-2.0 * lumaM) + lumaNS;\n" - " float edgeVert1 = (-2.0 * lumaM) + lumaWE;\n" - "/*--------------------------------------------------------------------------*/\n" - " float lumaNESE = lumaNE + lumaSE;\n" - " float lumaNWNE = lumaNW + lumaNE;\n" - " float edgeHorz2 = (-2.0 * lumaE) + lumaNESE;\n" - " float edgeVert2 = (-2.0 * lumaN) + lumaNWNE;\n" - "/*--------------------------------------------------------------------------*/\n" - " float lumaNWSW = lumaNW + lumaSW;\n" - " float lumaSWSE = lumaSW + lumaSE;\n" - " float edgeHorz4 = (abs(edgeHorz1) * 2.0) + abs(edgeHorz2);\n" - " float edgeVert4 = (abs(edgeVert1) * 2.0) + abs(edgeVert2);\n" - " float edgeHorz3 = (-2.0 * lumaW) + lumaNWSW;\n" - " float edgeVert3 = (-2.0 * lumaS) + lumaSWSE;\n" - " float edgeHorz = abs(edgeHorz3) + edgeHorz4;\n" - " float edgeVert = abs(edgeVert3) + edgeVert4;\n" - "/*--------------------------------------------------------------------------*/\n" - " float subpixNWSWNESE = lumaNWSW + lumaNESE;\n" - " float lengthSign = rcpFrame.x;\n" - " bool horzSpan = edgeHorz >= edgeVert;\n" - " float subpixA = subpixNSWE * 2.0 + subpixNWSWNESE;\n" - "/*--------------------------------------------------------------------------*/\n" - " if(!horzSpan) lumaN = lumaW;\n" - " if(!horzSpan) lumaS = lumaE;\n" - " if(horzSpan) lengthSign = rcpFrame.y;\n" - " float subpixB = (subpixA * (1.0/12.0)) - lumaM;\n" - "/*--------------------------------------------------------------------------*/\n" - " float gradientN = lumaN - lumaM;\n" - " float gradientS = lumaS - lumaM;\n" - " float lumaNN = lumaN + lumaM;\n" - " float lumaSS = lumaS + lumaM;\n" - " bool pairN = abs(gradientN) >= abs(gradientS);\n" - " float gradient = max(abs(gradientN), abs(gradientS));\n" - " if(pairN) lengthSign = -lengthSign;\n" - " float subpixC = FxaaSat(abs(subpixB) * subpixRcpRange);\n" - "/*--------------------------------------------------------------------------*/\n" - " float2 posB;\n" - " posB.x = posM.x;\n" - " posB.y = posM.y;\n" - " float2 offNP;\n" - " offNP.x = (!horzSpan) ? 0.0 : rcpFrame.x;\n" - " offNP.y = ( horzSpan) ? 0.0 : rcpFrame.y;\n" - " if(!horzSpan) posB.x += lengthSign * 0.5;\n" - " if( horzSpan) posB.y += lengthSign * 0.5;\n" - "/*--------------------------------------------------------------------------*/\n" - " float2 posN;\n" - " posN.x = posB.x - offNP.x * FXAA_QUALITY_P0;\n" - " posN.y = posB.y - offNP.y * FXAA_QUALITY_P0;\n" - " float2 posP;\n" - " posP.x = posB.x + offNP.x * FXAA_QUALITY_P0;\n" - " posP.y = posB.y + offNP.y * FXAA_QUALITY_P0;\n" - " float subpixD = ((-2.0)*subpixC) + 3.0;\n" - " float lumaEndN = FxaaTexTop(tex, posN).w;\n" - " float subpixE = subpixC * subpixC;\n" - " float lumaEndP = FxaaTexTop(tex, posP).w;\n" - "/*--------------------------------------------------------------------------*/\n" - " if(!pairN) lumaNN = lumaSS;\n" - " float gradientScaled = gradient * 1.0/4.0;\n" - " float lumaMM = lumaM - lumaNN * 0.5;\n" - " float subpixF = subpixD * subpixE;\n" - " bool lumaMLTZero = lumaMM < 0.0;\n" - "/*--------------------------------------------------------------------------*/\n" - " lumaEndN -= lumaNN * 0.5;\n" - " lumaEndP -= lumaNN * 0.5;\n" - " bool doneN = abs(lumaEndN) >= gradientScaled;\n" - " bool doneP = abs(lumaEndP) >= gradientScaled;\n" - " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P1;\n" - " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P1;\n" - " bool doneNP = (!doneN) || (!doneP);\n" - " if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P1;\n" - " if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P1;\n" - "/*--------------------------------------------------------------------------*/\n" - " if(doneNP) {\n" - " if(!doneN) lumaEndN = FxaaTexTop(tex, posN.xy).w;\n" - " if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w;\n" - " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" - " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" - " doneN = abs(lumaEndN) >= gradientScaled;\n" - " doneP = abs(lumaEndP) >= gradientScaled;\n" - " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P2;\n" - " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P2;\n" - " doneNP = (!doneN) || (!doneP);\n" - " if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P2;\n" - " if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P2;\n" - "/*--------------------------------------------------------------------------*/\n" - " #if (FXAA_QUALITY_PS > 3)\n" - " if(doneNP) {\n" - " if(!doneN) lumaEndN = FxaaTexTop(tex, posN.xy).w;\n" - " if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w;\n" - " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" - " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" - " doneN = abs(lumaEndN) >= gradientScaled;\n" - " doneP = abs(lumaEndP) >= gradientScaled;\n" - " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P3;\n" - " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P3;\n" - " doneNP = (!doneN) || (!doneP);\n" - " if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P3;\n" - " if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P3;\n" - "/*--------------------------------------------------------------------------*/\n" - " #if (FXAA_QUALITY_PS > 4)\n" - " if(doneNP) {\n" - " if(!doneN) lumaEndN = FxaaTexTop(tex, posN.xy).w;\n" - " if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w;\n" - " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" - " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" - " doneN = abs(lumaEndN) >= gradientScaled;\n" - " doneP = abs(lumaEndP) >= gradientScaled;\n" - " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P4;\n" - " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P4;\n" - " doneNP = (!doneN) || (!doneP);\n" - " if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P4;\n" - " if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P4;\n" - "/*--------------------------------------------------------------------------*/\n" - " #if (FXAA_QUALITY_PS > 5)\n" - " if(doneNP) {\n" - " if(!doneN) lumaEndN = FxaaTexTop(tex, posN.xy).w;\n" - " if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w;\n" - " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" - " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" - " doneN = abs(lumaEndN) >= gradientScaled;\n" - " doneP = abs(lumaEndP) >= gradientScaled;\n" - " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P5;\n" - " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P5;\n" - " doneNP = (!doneN) || (!doneP);\n" - " if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P5;\n" - " if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P5;\n" - "/*--------------------------------------------------------------------------*/\n" - " #if (FXAA_QUALITY_PS > 6)\n" - " if(doneNP) {\n" - " if(!doneN) lumaEndN = FxaaTexTop(tex, posN.xy).w;\n" - " if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w;\n" - " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" - " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" - " doneN = abs(lumaEndN) >= gradientScaled;\n" - " doneP = abs(lumaEndP) >= gradientScaled;\n" - " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P6;\n" - " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P6;\n" - " doneNP = (!doneN) || (!doneP);\n" - " if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P6;\n" - " if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P6;\n" - "/*--------------------------------------------------------------------------*/\n" - " #if (FXAA_QUALITY_PS > 7)\n" - " if(doneNP) {\n" - " if(!doneN) lumaEndN = FxaaTexTop(tex, posN.xy).w;\n" - " if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w;\n" - " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" - " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" - " doneN = abs(lumaEndN) >= gradientScaled;\n" - " doneP = abs(lumaEndP) >= gradientScaled;\n" - " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P7;\n" - " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P7;\n" - " doneNP = (!doneN) || (!doneP);\n" - " if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P7;\n" - " if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P7;\n" - "/*--------------------------------------------------------------------------*/\n" - " #if (FXAA_QUALITY_PS > 8)\n" - " if(doneNP) {\n" - " if(!doneN) lumaEndN = FxaaTexTop(tex, posN.xy).w;\n" - " if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w;\n" - " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" - " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" - " doneN = abs(lumaEndN) >= gradientScaled;\n" - " doneP = abs(lumaEndP) >= gradientScaled;\n" - " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P8;\n" - " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P8;\n" - " doneNP = (!doneN) || (!doneP);\n" - " if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P8;\n" - " if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P8;\n" - "/*--------------------------------------------------------------------------*/\n" - " #if (FXAA_QUALITY_PS > 9)\n" - " if(doneNP) {\n" - " if(!doneN) lumaEndN = FxaaTexTop(tex, posN.xy).w;\n" - " if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w;\n" - " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" - " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" - " doneN = abs(lumaEndN) >= gradientScaled;\n" - " doneP = abs(lumaEndP) >= gradientScaled;\n" - " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P9;\n" - " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P9;\n" - " doneNP = (!doneN) || (!doneP);\n" - " if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P9;\n" - " if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P9;\n" - "/*--------------------------------------------------------------------------*/\n" - " #if (FXAA_QUALITY_PS > 10)\n" - " if(doneNP) {\n" - " if(!doneN) lumaEndN = FxaaTexTop(tex, posN.xy).w;\n" - " if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w;\n" - " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" - " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" - " doneN = abs(lumaEndN) >= gradientScaled;\n" - " doneP = abs(lumaEndP) >= gradientScaled;\n" - " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P10;\n" - " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P10;\n" - " doneNP = (!doneN) || (!doneP);\n" - " if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P10;\n" - " if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P10;\n" - "/*--------------------------------------------------------------------------*/\n" - " #if (FXAA_QUALITY_PS > 11)\n" - " if(doneNP) {\n" - " if(!doneN) lumaEndN = FxaaTexTop(tex, posN.xy).w;\n" - " if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w;\n" - " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" - " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" - " doneN = abs(lumaEndN) >= gradientScaled;\n" - " doneP = abs(lumaEndP) >= gradientScaled;\n" - " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P11;\n" - " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P11;\n" - " doneNP = (!doneN) || (!doneP);\n" - " if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P11;\n" - " if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P11;\n" - "/*--------------------------------------------------------------------------*/\n" - " #if (FXAA_QUALITY_PS > 12)\n" - " if(doneNP) {\n" - " if(!doneN) lumaEndN = FxaaTexTop(tex, posN.xy).w;\n" - " if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w;\n" - " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" - " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" - " doneN = abs(lumaEndN) >= gradientScaled;\n" - " doneP = abs(lumaEndP) >= gradientScaled;\n" - " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P12;\n" - " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P12;\n" - " doneNP = (!doneN) || (!doneP);\n" - " if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P12;\n" - " if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P12;\n" - "/*--------------------------------------------------------------------------*/\n" - " }\n" - " #endif\n" - "/*--------------------------------------------------------------------------*/\n" - " }\n" - " #endif\n" - "/*--------------------------------------------------------------------------*/\n" - " }\n" - " #endif\n" - "/*--------------------------------------------------------------------------*/\n" - " }\n" - " #endif\n" - "/*--------------------------------------------------------------------------*/\n" - " }\n" - " #endif\n" - "/*--------------------------------------------------------------------------*/\n" - " }\n" - " #endif\n" - "/*--------------------------------------------------------------------------*/\n" - " }\n" - " #endif\n" - "/*--------------------------------------------------------------------------*/\n" - " }\n" - " #endif\n" - "/*--------------------------------------------------------------------------*/\n" - " }\n" - " #endif\n" - "/*--------------------------------------------------------------------------*/\n" - " }\n" - " #endif\n" - "/*--------------------------------------------------------------------------*/\n" - " }\n" - "/*--------------------------------------------------------------------------*/\n" - " float dstN = posM.x - posN.x;\n" - " float dstP = posP.x - posM.x;\n" - " if(!horzSpan) dstN = posM.y - posN.y;\n" - " if(!horzSpan) dstP = posP.y - posM.y;\n" - "/*--------------------------------------------------------------------------*/\n" - " bool goodSpanN = (lumaEndN < 0.0) != lumaMLTZero;\n" - " float spanLength = (dstP + dstN);\n" - " bool goodSpanP = (lumaEndP < 0.0) != lumaMLTZero;\n" - " float spanLengthRcp = 1.0/spanLength;\n" - "/*--------------------------------------------------------------------------*/\n" - " bool directionN = dstN < dstP;\n" - " float dst = min(dstN, dstP);\n" - " bool goodSpan = directionN ? goodSpanN : goodSpanP;\n" - " float subpixG = subpixF * subpixF;\n" - " float pixelOffset = (dst * (-spanLengthRcp)) + 0.5;\n" - " float subpixH = subpixG * FXAA_QUALITY_SUBPIX;\n" - "/*--------------------------------------------------------------------------*/\n" - " float pixelOffsetGood = goodSpan ? pixelOffset : 0.0;\n" - " float pixelOffsetSubpix = max(pixelOffsetGood, subpixH);\n" - " if(!horzSpan) posM.x += pixelOffsetSubpix * lengthSign;\n" - " if( horzSpan) posM.y += pixelOffsetSubpix * lengthSign;\n" - " #if (FXAA_DISCARD == 1)\n" - " return FxaaTexTop(tex, posM);\n" - " #else\n" - " return float4(FxaaTexTop(tex, posM).xyz, lumaM);\n" - " #endif\n" - "}\n" - "/*==========================================================================*/\n" - "#endif\n" - "\n" - "#ifdef SHADER_MODEL\n" - "PS_OUTPUT ps_main(PS_INPUT input)\n" + "cbuffer cb0\n" "{\n" - " PS_OUTPUT output;\n" + " float4 _rcpFrame : register(c0);\n" + "};\n" "\n" - " float2 pos = input.t;\n" - " float4 posPos = (float4)0;\n" + "struct VS_INPUT\n" + "{\n" + " float4 p : POSITION;\n" + " float2 t : TEXCOORD0;\n" + "};\n" "\n" + "struct VS_OUTPUT\n" + "{\n" + " #if (SHADER_MODEL >= 0x400)\n" + " float4 p : SV_Position;\n" + " #else\n" + " float4 p : TEXCOORD1;\n" + " #endif\n" + " float2 t : TEXCOORD0;\n" + "};\n" + "\n" + "struct PS_OUTPUT\n" + "{\n" + " #if (SHADER_MODEL >= 0x400)\n" + " float4 c : SV_Target0;\n" + " #else\n" + " float4 c : COLOR0;\n" + " #endif\n" + "};\n" + "\n" + "#endif\n" + "\n" + "/*------------------------------------------------------------------------------\n" + " [FXAA CODE SECTION]\n" + "------------------------------------------------------------------------------*/\n" + "\n" + "#if (SHADER_MODEL >= 0x500)\n" + "#define FXAA_HLSL_5 1\n" + "#define FXAA_GATHER4_ALPHA 1\n" + "#elif (SHADER_MODEL >= 0x400)\n" + "#define FXAA_HLSL_4 1\n" + "#define FXAA_GATHER4_ALPHA 0\n" + "#elif (FXAA_GLSL_130 == 1)\n" + "#define FXAA_GATHER4_ALPHA 1\n" + "#else\n" + "#define FXAA_HLSL_3 1\n" + "#define FXAA_GATHER4_ALPHA 0\n" + "#endif\n" + "\n" + "#if (FXAA_HLSL_5 == 1)\n" + "struct FxaaTex { SamplerState smpl; Texture2D tex; };\n" + "#define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)\n" + "#define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)\n" + "#define FxaaTexAlpha4(t, p) t.tex.GatherAlpha(t.smpl, p)\n" + "#define FxaaTexOffAlpha4(t, p, o) t.tex.GatherAlpha(t.smpl, p, o)\n" + "#define FxaaDiscard clip(-1)\n" + "#define FxaaSat(x) saturate(x)\n" + "\n" + "#elif (FXAA_HLSL_4 == 1)\n" + "struct FxaaTex { SamplerState smpl; Texture2D tex; };\n" + "#define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0)\n" + "#define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o)\n" + "#define FxaaDiscard clip(-1)\n" + "#define FxaaSat(x) saturate(x)\n" + "\n" + "#elif (FXAA_HLSL_3 == 1)\n" + "#define FxaaTex sampler2D\n" + "#define int2 float2\n" + "#define FxaaSat(x) saturate(x)\n" + "#define FxaaTexTop(t, p) tex2Dlod(t, float4(p, 0.0, 0.0))\n" + "#define FxaaTexOff(t, p, o, r) tex2Dlod(t, float4(p + (o * r), 0, 0))\n" + "\n" + "#elif (FXAA_GLSL_130 == 1)\n" + "\n" + "#define int2 ivec2\n" + "#define float2 vec2\n" + "#define float3 vec3\n" + "#define float4 vec4\n" + "#define FxaaDiscard discard\n" + "#define FxaaSat(x) clamp(x, 0.0, 1.0)\n" + "#define FxaaTex sampler2D\n" + "#define FxaaTexTop(t, p) textureLod(t, p, 0.0)\n" + "#define FxaaTexOff(t, p, o, r) textureLodOffset(t, p, 0.0, o)\n" + "#if (FXAA_GATHER4_ALPHA == 1)\n" + "// use #extension GL_ARB_gpu_shader5 : enable\n" + "#define FxaaTexAlpha4(t, p) textureGather(t, p, 3)\n" + "#define FxaaTexOffAlpha4(t, p, o) textureGatherOffset(t, p, o, 3)\n" + "#endif\n" + "\n" + "#endif\n" + "\n" + "#define FxaaEdgeThreshold 0.063\n" + "#define FxaaEdgeThresholdMin 0.00\n" + "#define FXAA_QUALITY__P0 1.0\n" + "#define FXAA_QUALITY__P1 1.5\n" + "#define FXAA_QUALITY__P2 2.0\n" + "#define FXAA_QUALITY__P3 2.0\n" + "#define FXAA_QUALITY__P4 2.0\n" + "#define FXAA_QUALITY__P5 2.0\n" + "#define FXAA_QUALITY__P6 2.0\n" + "#define FXAA_QUALITY__P7 2.0\n" + "#define FXAA_QUALITY__P8 2.0\n" + "#define FXAA_QUALITY__P9 2.0\n" + "#define FXAA_QUALITY__P10 4.0\n" + "#define FXAA_QUALITY__P11 8.0\n" + "#define FXAA_QUALITY__P12 8.0\n" + "\n" + "/*------------------------------------------------------------------------------\n" + " [GAMMA PREPASS CODE SECTION]\n" + "------------------------------------------------------------------------------*/\n" + "float RGBLuminance(float3 color)\n" + "{\n" + " const float3 lumCoeff = float3(0.2126729, 0.7151522, 0.0721750);\n" + " return dot(color.rgb, lumCoeff);\n" + "}\n" + "\n" + "#if (FXAA_GLSL_130 == 0)\n" + "#define PixelSize float2(_rcpFrame.x, _rcpFrame.y)\n" + "#endif\n" + "\n" + "\n" + "float3 RGBGammaToLinear(float3 color, float gamma)\n" + "{\n" + " color = FxaaSat(color);\n" + " color.r = (color.r <= 0.0404482362771082) ?\n" + " color.r / 12.92 : pow((color.r + 0.055) / 1.055, gamma);\n" + " color.g = (color.g <= 0.0404482362771082) ?\n" + " color.g / 12.92 : pow((color.g + 0.055) / 1.055, gamma);\n" + " color.b = (color.b <= 0.0404482362771082) ?\n" + " color.b / 12.92 : pow((color.b + 0.055) / 1.055, gamma);\n" + "\n" + " return color;\n" + "}\n" + "\n" + "float3 LinearToRGBGamma(float3 color, float gamma)\n" + "{\n" + " color = FxaaSat(color);\n" + " color.r = (color.r <= 0.00313066844250063) ?\n" + " color.r * 12.92 : 1.055 * pow(color.r, 1.0 / gamma) - 0.055;\n" + " color.g = (color.g <= 0.00313066844250063) ?\n" + " color.g * 12.92 : 1.055 * pow(color.g, 1.0 / gamma) - 0.055;\n" + " color.b = (color.b <= 0.00313066844250063) ?\n" + " color.b * 12.92 : 1.055 * pow(color.b, 1.0 / gamma) - 0.055;\n" + "\n" + " return color;\n" + "}\n" + "\n" + "float4 PreGammaPass(float4 color, float2 uv0)\n" + "{\n" + " #if (SHADER_MODEL >= 0x400)\n" + " color = Texture.Sample(TextureSampler, uv0);\n" + " #elif (FXAA_GLSL_130 == 1)\n" + " color = texture(TextureSampler, uv0);\n" + " #else\n" + " color = tex2D(TextureSampler, uv0);\n" + " #endif\n" + "\n" + " const float GammaConst = 2.233;\n" + " color.rgb = RGBGammaToLinear(color.rgb, GammaConst);\n" + " color.rgb = LinearToRGBGamma(color.rgb, GammaConst);\n" + " color.a = RGBLuminance(color.rgb);\n" + "\n" + " return color;\n" + "}\n" + "\n" + "\n" + "/*------------------------------------------------------------------------------\n" + " [FXAA CODE SECTION]\n" + "------------------------------------------------------------------------------*/\n" + "\n" + "float FxaaLuma(float4 rgba)\n" + "{ \n" + " rgba.w = RGBLuminance(rgba.xyz);\n" + " return rgba.w; \n" + "}\n" + "\n" + "float4 FxaaPixelShader(float2 pos, FxaaTex tex, float2 fxaaRcpFrame, float fxaaSubpix, float fxaaEdgeThreshold, float fxaaEdgeThresholdMin)\n" + "{\n" + " float2 posM;\n" + " posM.x = pos.x;\n" + " posM.y = pos.y;\n" + "\n" + " #if (FXAA_GATHER4_ALPHA == 1)\n" + " float4 rgbyM = FxaaTexTop(tex, posM);\n" + " float4 luma4A = FxaaTexAlpha4(tex, posM);\n" + " float4 luma4B = FxaaTexOffAlpha4(tex, posM, int2(-1, -1));\n" + " rgbyM.w = RGBLuminance(rgbyM.xyz);\n" + "\n" + " #define lumaM rgbyM.w\n" + " #define lumaE luma4A.z\n" + " #define lumaS luma4A.x\n" + " #define lumaSE luma4A.y\n" + " #define lumaNW luma4B.w\n" + " #define lumaN luma4B.z\n" + " #define lumaW luma4B.x\n" + " \n" + " #else\n" + " float4 rgbyM = FxaaTexTop(tex, posM);\n" + " rgbyM.w = RGBLuminance(rgbyM.xyz);\n" + " #define lumaM rgbyM.w\n" + "\n" + " float lumaS = FxaaLuma(FxaaTexOff(tex, posM, int2( 0, 1), fxaaRcpFrame.xy));\n" + " float lumaE = FxaaLuma(FxaaTexOff(tex, posM, int2( 1, 0), fxaaRcpFrame.xy));\n" + " float lumaN = FxaaLuma(FxaaTexOff(tex, posM, int2( 0,-1), fxaaRcpFrame.xy));\n" + " float lumaW = FxaaLuma(FxaaTexOff(tex, posM, int2(-1, 0), fxaaRcpFrame.xy));\n" + " #endif\n" + "\n" + " float maxSM = max(lumaS, lumaM);\n" + " float minSM = min(lumaS, lumaM);\n" + " float maxESM = max(lumaE, maxSM);\n" + " float minESM = min(lumaE, minSM);\n" + " float maxWN = max(lumaN, lumaW);\n" + " float minWN = min(lumaN, lumaW);\n" + "\n" + " float rangeMax = max(maxWN, maxESM);\n" + " float rangeMin = min(minWN, minESM);\n" + " float range = rangeMax - rangeMin;\n" + " float rangeMaxScaled = rangeMax * fxaaEdgeThreshold;\n" + " float rangeMaxClamped = max(fxaaEdgeThresholdMin, rangeMaxScaled);\n" + "\n" + " bool earlyExit = range < rangeMaxClamped;\n" + " #if (FxaaEarlyExit == 1)\n" + " if(earlyExit) { return rgbyM; }\n" + " #endif\n" + "\n" + " #if (FXAA_GATHER4_ALPHA == 0)\n" + " float lumaNW = FxaaLuma(FxaaTexOff(tex, posM, int2(-1,-1), fxaaRcpFrame.xy));\n" + " float lumaSE = FxaaLuma(FxaaTexOff(tex, posM, int2( 1, 1), fxaaRcpFrame.xy));\n" + " float lumaNE = FxaaLuma(FxaaTexOff(tex, posM, int2( 1,-1), fxaaRcpFrame.xy));\n" + " float lumaSW = FxaaLuma(FxaaTexOff(tex, posM, int2(-1, 1), fxaaRcpFrame.xy));\n" + " #else\n" + " float lumaNE = FxaaLuma(FxaaTexOff(tex, posM, int2( 1,-1), fxaaRcpFrame.xy));\n" + " float lumaSW = FxaaLuma(FxaaTexOff(tex, posM, int2(-1, 1), fxaaRcpFrame.xy));\n" + " #endif\n" + "\n" + " float lumaNS = lumaN + lumaS;\n" + " float lumaWE = lumaW + lumaE;\n" + " float subpixRcpRange = 1.0/range;\n" + " float subpixNSWE = lumaNS + lumaWE;\n" + " float edgeHorz1 = (-2.0 * lumaM) + lumaNS;\n" + " float edgeVert1 = (-2.0 * lumaM) + lumaWE;\n" + " float lumaNESE = lumaNE + lumaSE;\n" + " float lumaNWNE = lumaNW + lumaNE;\n" + " float edgeHorz2 = (-2.0 * lumaE) + lumaNESE;\n" + " float edgeVert2 = (-2.0 * lumaN) + lumaNWNE;\n" + "\n" + " float lumaNWSW = lumaNW + lumaSW;\n" + " float lumaSWSE = lumaSW + lumaSE;\n" + " float edgeHorz4 = (abs(edgeHorz1) * 2.0) + abs(edgeHorz2);\n" + " float edgeVert4 = (abs(edgeVert1) * 2.0) + abs(edgeVert2);\n" + " float edgeHorz3 = (-2.0 * lumaW) + lumaNWSW;\n" + " float edgeVert3 = (-2.0 * lumaS) + lumaSWSE;\n" + " float edgeHorz = abs(edgeHorz3) + edgeHorz4;\n" + " float edgeVert = abs(edgeVert3) + edgeVert4;\n" + "\n" + " float subpixNWSWNESE = lumaNWSW + lumaNESE;\n" + " float lengthSign = fxaaRcpFrame.x;\n" + " bool horzSpan = edgeHorz >= edgeVert;\n" + " float subpixA = subpixNSWE * 2.0 + subpixNWSWNESE;\n" + " if(!horzSpan) lumaN = lumaW;\n" + " if(!horzSpan) lumaS = lumaE;\n" + " if(horzSpan) lengthSign = fxaaRcpFrame.y;\n" + " float subpixB = (subpixA * (1.0/12.0)) - lumaM;\n" + "\n" + " float gradientN = lumaN - lumaM;\n" + " float gradientS = lumaS - lumaM;\n" + " float lumaNN = lumaN + lumaM;\n" + " float lumaSS = lumaS + lumaM;\n" + " bool pairN = abs(gradientN) >= abs(gradientS);\n" + " float gradient = max(abs(gradientN), abs(gradientS));\n" + " if(pairN) lengthSign = -lengthSign;\n" + " float subpixC = FxaaSat(abs(subpixB) * subpixRcpRange);\n" + "\n" + " float2 posB;\n" + " posB.x = posM.x;\n" + " posB.y = posM.y;\n" + " float2 offNP;\n" + " offNP.x = (!horzSpan) ? 0.0 : fxaaRcpFrame.x;\n" + " offNP.y = ( horzSpan) ? 0.0 : fxaaRcpFrame.y;\n" + " if(!horzSpan) posB.x += lengthSign * 0.5;\n" + " if( horzSpan) posB.y += lengthSign * 0.5;\n" + "\n" + " float2 posN;\n" + " posN.x = posB.x - offNP.x * FXAA_QUALITY__P0;\n" + " posN.y = posB.y - offNP.y * FXAA_QUALITY__P0;\n" + " float2 posP;\n" + " posP.x = posB.x + offNP.x * FXAA_QUALITY__P0;\n" + " posP.y = posB.y + offNP.y * FXAA_QUALITY__P0;\n" + " float subpixD = ((-2.0)*subpixC) + 3.0;\n" + " float lumaEndN = FxaaLuma(FxaaTexTop(tex, posN));\n" + " float subpixE = subpixC * subpixC;\n" + " float lumaEndP = FxaaLuma(FxaaTexTop(tex, posP));\n" + "\n" + " if(!pairN) lumaNN = lumaSS;\n" + " float gradientScaled = gradient * 1.0/4.0;\n" + " float lumaMM = lumaM - lumaNN * 0.5;\n" + " float subpixF = subpixD * subpixE;\n" + " bool lumaMLTZero = lumaMM < 0.0;\n" + " lumaEndN -= lumaNN * 0.5;\n" + " lumaEndP -= lumaNN * 0.5;\n" + " bool doneN = abs(lumaEndN) >= gradientScaled;\n" + " bool doneP = abs(lumaEndP) >= gradientScaled;\n" + " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P1;\n" + " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P1;\n" + " bool doneNP = (!doneN) || (!doneP);\n" + " if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P1;\n" + " if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P1;\n" + "\n" + " if(doneNP) {\n" + " if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n" + " if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n" + " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" + " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" + " doneN = abs(lumaEndN) >= gradientScaled;\n" + " doneP = abs(lumaEndP) >= gradientScaled;\n" + " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P2;\n" + " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P2;\n" + " doneNP = (!doneN) || (!doneP);\n" + " if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P2;\n" + " if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P2;\n" + "\n" + " if(doneNP) {\n" + " if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n" + " if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n" + " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" + " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" + " doneN = abs(lumaEndN) >= gradientScaled;\n" + " doneP = abs(lumaEndP) >= gradientScaled;\n" + " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P3;\n" + " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P3;\n" + " doneNP = (!doneN) || (!doneP);\n" + " if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P3;\n" + " if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P3;\n" + "\n" + " if(doneNP) {\n" + " if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n" + " if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n" + " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" + " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" + " doneN = abs(lumaEndN) >= gradientScaled;\n" + " doneP = abs(lumaEndP) >= gradientScaled;\n" + " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P4;\n" + " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P4;\n" + " doneNP = (!doneN) || (!doneP);\n" + " if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P4;\n" + " if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P4;\n" + "\n" + " if(doneNP) {\n" + " if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n" + " if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n" + " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" + " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" + " doneN = abs(lumaEndN) >= gradientScaled;\n" + " doneP = abs(lumaEndP) >= gradientScaled;\n" + " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P5;\n" + " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P5;\n" + " doneNP = (!doneN) || (!doneP);\n" + " if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P5;\n" + " if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P5;\n" + "\n" + " if(doneNP) {\n" + " if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n" + " if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n" + " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" + " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" + " doneN = abs(lumaEndN) >= gradientScaled;\n" + " doneP = abs(lumaEndP) >= gradientScaled;\n" + " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P6;\n" + " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P6;\n" + " doneNP = (!doneN) || (!doneP);\n" + " if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P6;\n" + " if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P6;\n" + "\n" + " if(doneNP) {\n" + " if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n" + " if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n" + " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" + " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" + " doneN = abs(lumaEndN) >= gradientScaled;\n" + " doneP = abs(lumaEndP) >= gradientScaled;\n" + " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P7;\n" + " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P7;\n" + " doneNP = (!doneN) || (!doneP);\n" + " if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P7;\n" + " if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P7;\n" + "\n" + " if(doneNP) {\n" + " if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n" + " if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n" + " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" + " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" + " doneN = abs(lumaEndN) >= gradientScaled;\n" + " doneP = abs(lumaEndP) >= gradientScaled;\n" + " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P8;\n" + " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P8;\n" + " doneNP = (!doneN) || (!doneP);\n" + " if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P8;\n" + " if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P8;\n" + "\n" + " if(doneNP) {\n" + " if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n" + " if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n" + " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" + " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" + " doneN = abs(lumaEndN) >= gradientScaled;\n" + " doneP = abs(lumaEndP) >= gradientScaled;\n" + " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P9;\n" + " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P9;\n" + " doneNP = (!doneN) || (!doneP);\n" + " if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P9;\n" + " if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P9;\n" + "\n" + " if(doneNP) {\n" + " if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n" + " if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n" + " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" + " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" + " doneN = abs(lumaEndN) >= gradientScaled;\n" + " doneP = abs(lumaEndP) >= gradientScaled;\n" + " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P10;\n" + " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P10;\n" + " doneNP = (!doneN) || (!doneP);\n" + " if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P10;\n" + " if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P10;\n" + "\n" + " if(doneNP) {\n" + " if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n" + " if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n" + " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" + " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" + " doneN = abs(lumaEndN) >= gradientScaled;\n" + " doneP = abs(lumaEndP) >= gradientScaled;\n" + " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P11;\n" + " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P11;\n" + " doneNP = (!doneN) || (!doneP);\n" + " if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P11;\n" + " if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P11;\n" + "\n" + " if(doneNP) {\n" + " if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));\n" + " if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));\n" + " if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;\n" + " if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;\n" + " doneN = abs(lumaEndN) >= gradientScaled;\n" + " doneP = abs(lumaEndP) >= gradientScaled;\n" + " if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P12;\n" + " if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P12;\n" + " doneNP = (!doneN) || (!doneP);\n" + " if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P12;\n" + " if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P12;\n" + " }}}}}}}}}}}\n" + "\n" + " float dstN = posM.x - posN.x;\n" + " float dstP = posP.x - posM.x;\n" + " if(!horzSpan) dstN = posM.y - posN.y;\n" + " if(!horzSpan) dstP = posP.y - posM.y;\n" + "\n" + " bool goodSpanN = (lumaEndN < 0.0) != lumaMLTZero;\n" + " float spanLength = (dstP + dstN);\n" + " bool goodSpanP = (lumaEndP < 0.0) != lumaMLTZero;\n" + " float spanLengthRcp = 1.0/spanLength;\n" + "\n" + " bool directionN = dstN < dstP;\n" + " float dst = min(dstN, dstP);\n" + " bool goodSpan = directionN ? goodSpanN : goodSpanP;\n" + " float subpixG = subpixF * subpixF;\n" + " float pixelOffset = (dst * (-spanLengthRcp)) + 0.5;\n" + " float subpixH = subpixG * fxaaSubpix;\n" + "\n" + " float pixelOffsetGood = goodSpan ? pixelOffset : 0.0;\n" + " float pixelOffsetSubpix = max(pixelOffsetGood, subpixH);\n" + " if(!horzSpan) posM.x += pixelOffsetSubpix * lengthSign;\n" + " if( horzSpan) posM.y += pixelOffsetSubpix * lengthSign;\n" + "\n" + " return float4(FxaaTexTop(tex, posM).xyz, lumaM);\n" + "}\n" + "\n" + "#if (FXAA_GLSL_130 == 1)\n" + "float4 FxaaPass(float4 FxaaColor, float2 uv0)\n" + "#else\n" + "float4 FxaaPass(float4 FxaaColor : COLOR0, float2 uv0 : TEXCOORD0)\n" + "#endif\n" + "{\n" " FxaaTex tex;\n" "\n" - " #if SHADER_MODEL >= 0x400\n" - "\n" + " #if (SHADER_MODEL >= 0x400)\n" " tex.tex = Texture;\n" " tex.smpl = TextureSampler;\n" "\n" + " Texture.GetDimensions(PixelSize.x, PixelSize.y);\n" + " FxaaColor = FxaaPixelShader(uv0, tex, 1.0/PixelSize.xy, FxaaSubpixMax, FxaaEdgeThreshold, FxaaEdgeThresholdMin);\n" + "\n" + " #elif (FXAA_GLSL_130 == 1)\n" + "\n" + " tex = TextureSampler;\n" + " vec2 PixelSize = textureSize(tex, 0);\n" + " FxaaColor = FxaaPixelShader(uv0, tex, 1.0/PixelSize.xy, FxaaSubpixMax, FxaaEdgeThreshold, FxaaEdgeThresholdMin);\n" + "\n" " #else\n" "\n" - " tex = Texture;\n" - "\n" + " tex = TextureSampler;\n" + " FxaaColor = FxaaPixelShader(uv0, tex, PixelSize.xy, FxaaSubpixMax, FxaaEdgeThreshold, FxaaEdgeThresholdMin);\n" " #endif\n" "\n" - " output.c = FxaaPixelShader(pos, posPos, tex, _rcpFrame.xy, _rcpFrameOpt);\n" - "\n" - " return output;\n" + " return FxaaColor;\n" "}\n" - "#endif\n" "\n" + "/*------------------------------------------------------------------------------\n" + " [MAIN() & COMBINE PASS CODE SECTION]\n" + "------------------------------------------------------------------------------*/\n" "#if (FXAA_GLSL_130 == 1)\n" + "\n" "void ps_main()\n" "{\n" - " vec2 pos = PSin_t;\n" - " vec4 posPos = vec4(0.0, 0.0, 0.0, 0.0);\n" + " vec4 color = texture(TextureSampler, PSin.t);\n" + " color = PreGammaPass(color, PSin.t);\n" + " color = FxaaPass(color, PSin.t);\n" "\n" - " SV_Target0 = FxaaPixelShader(pos, posPos, TextureSampler, _rcpFrame.xy, _rcpFrameOpt);\n" + " SV_Target0 = color;\n" "}\n" + "\n" + "#else\n" + "\n" + "PS_OUTPUT ps_main(VS_OUTPUT input)\n" + "{\n" + " PS_OUTPUT output;\n" + "\n" + " #if (SHADER_MODEL >= 0x400)\n" + " float4 color = Texture.Sample(TextureSampler, input.t);\n" + "\n" + " color = PreGammaPass(color, input.t);\n" + " color = FxaaPass(color, input.t);\n" + " #else\n" + " float4 color = tex2D(TextureSampler, input.t);\n" + "\n" + " color = PreGammaPass(color, input.t);\n" + " color = FxaaPass(color, input.t);\n" + " #endif\n" + "\n" + " output.c = color;\n" + " \n" + " return output;\n" + "}\n" + "\n" "#endif\n" "\n" "#endif\n" diff --git a/plugins/GSdx/res/old_fxaa.fx b/plugins/GSdx/res/old_fxaa.fx deleted file mode 100644 index 48c4ad96c9..0000000000 --- a/plugins/GSdx/res/old_fxaa.fx +++ /dev/null @@ -1,1230 +0,0 @@ -#if defined(SHADER_MODEL) || defined(FXAA_GLSL_130) // make safe to include in resource file to enforce dependency - -#ifndef FXAA_GLSL_130 - #define FXAA_GLSL_130 0 -#endif - -#define FXAA_PC 1 -#define FXAA_QUALITY_SUBPIX 0.0 - -#ifdef SHADER_MODEL -#if SHADER_MODEL >= 0x400 - -#if SHADER_MODEL >= 0x500 - #define FXAA_HLSL_5 1 -#else - #define FXAA_HLSL_4 1 -#endif - -Texture2D Texture; -SamplerState TextureSampler; - -cbuffer cb0 -{ - float4 _rcpFrame; - float4 _rcpFrameOpt; -}; - -struct PS_INPUT -{ - float4 p : SV_Position; - float2 t : TEXCOORD0; -}; - -struct PS_OUTPUT -{ - float4 c : SV_Target0; -}; - -#elif SHADER_MODEL <= 0x300 - -#define FXAA_HLSL_3 1 - -sampler Texture : register(s0); - -float4 _rcpFrame : register(c0); -float4 _rcpFrameOpt : register(c1); - -struct PS_INPUT -{ -#if SHADER_MODEL < 0x300 - float4 p : TEXCOORD1; -#else - float4 p : VPOS; -#endif - float2 t : TEXCOORD0; -}; - -struct PS_OUTPUT -{ - float4 c : COLOR; -}; - -#endif -#endif - - -#if (FXAA_GLSL_130 == 1) -struct vertex_basic -{ - vec4 p; - vec2 t; -}; - -layout(std140, binding = 13) uniform cb13 -{ - vec4 _rcpFrame; - vec4 _rcpFrameOpt; -}; - -#ifdef ENABLE_BINDLESS_TEX -layout(bindless_sampler, location = 0) uniform sampler2D TextureSampler; -#else -layout(binding = 0) uniform sampler2D TextureSampler; -#endif - -in SHADER -{ - vec4 p; - vec2 t; -} PSin; - -#define PSin_p (PSin.p) -#define PSin_t (PSin.t) - -layout(location = 0) out vec4 SV_Target0; - -#endif - -/*============================================================================ - - - NVIDIA FXAA 3.10 by TIMOTHY LOTTES - - ------------------------------------------------------------------------------- -COPYRIGHT (C) 2010, 2011 NVIDIA CORPORATION. ALL RIGHTS RESERVED. ------------------------------------------------------------------------------- -TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED -*AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS -OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF -MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL NVIDIA -OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR -CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR -LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, -OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR INABILITY TO USE -THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH -DAMAGES. - ------------------------------------------------------------------------------- - INTEGRATION CHECKLIST ------------------------------------------------------------------------------- -(1.) -In the shader source, -setup defines for the desired configuration. -Example, - - #define FXAA_PC 1 - #define FXAA_HLSL_3 1 - #define FXAA_QUALITY_PRESET 12 - #define FXAA_QUALITY_EDGE_THRESHOLD (1.0/6.0) - #define FXAA_QUALITY_EDGE_THRESHOLD_MIN (1.0/12.0) - -(2.) -Then include this file, - - #include "Fxaa3.h" - -(3.) -Then call the FXAA pixel shader from within your desired shader, - - return FxaaPixelShader(pos, posPos, tex, rcpFrame, rcpFrameOpt); - -(4.) -Insure pass prior to FXAA outputs RGBL. -See next section. - -(5.) -Setup engine to provide "rcpFrame" and "rcpFrameOpt" constants. -Not using constants will result in a performance loss. - - // {x_} = 1.0/screenWidthInPixels - // {_y} = 1.0/screenHeightInPixels - float2 rcpFrame - - // This must be from a constant/uniform. - // {x___} = 2.0/screenWidthInPixels - // {_y__} = 2.0/screenHeightInPixels - // {__z_} = 0.5/screenWidthInPixels - // {___w} = 0.5/screenHeightInPixels - float4 rcpFrameOpt - -(5.a.) -Optionally change to this for sharper FXAA Console, - - // This must be from a constant/uniform. - // {x___} = 2.0/screenWidthInPixels - // {_y__} = 2.0/screenHeightInPixels - // {__z_} = 0.333/screenWidthInPixels - // {___w} = 0.333/screenHeightInPixels - float4 rcpFrameOpt - -(6.) -Have FXAA vertex shader run as a full screen triangle, -and output "pos" and "posPos" such that inputs in the pixel shader provide, - - // {xy} = center of pixel - float2 pos, - - // {xy__} = upper left of pixel - // {__zw} = lower right of pixel - float4 posPos, - -(7.) -Insure the texture sampler used by FXAA is set to bilinear filtering. - - ------------------------------------------------------------------------------- - INTEGRATION - RGBL AND COLORSPACE ------------------------------------------------------------------------------- -FXAA3 requires RGBL as input. - -RGB should be LDR (low dynamic range). -Specifically do FXAA after tonemapping. - -RGB data as returned by a texture fetch can be linear or non-linear. -Note an "sRGB format" texture counts as linear, -because the result of a texture fetch is linear data. -Regular "RGBA8" textures in the sRGB colorspace are non-linear. - -Luma must be stored in the alpha channel prior to running FXAA. -This luma should be in a perceptual space (could be gamma 2.0). -Example pass before FXAA where output is gamma 2.0 encoded, - - color.rgb = ToneMap(color.rgb); // linear color output - color.rgb = sqrt(color.rgb); // gamma 2.0 color output - return color; - -To use FXAA, - - color.rgb = ToneMap(color.rgb); // linear color output - color.rgb = sqrt(color.rgb); // gamma 2.0 color output - color.a = dot(color.rgb, float3(0.299, 0.587, 0.114)); // compute luma - return color; - -Another example where output is linear encoded, -say for instance writing to an sRGB formated render target, -where the render target does the conversion back to sRGB after blending, - - color.rgb = ToneMap(color.rgb); // linear color output - return color; - -To use FXAA, - - color.rgb = ToneMap(color.rgb); // linear color output - color.a = sqrt(dot(color.rgb, float3(0.299, 0.587, 0.114))); // compute luma - return color; - -Getting luma correct is required for the algorithm to work correctly. - - ------------------------------------------------------------------------------- - BEING LINEARLY CORRECT? ------------------------------------------------------------------------------- -Applying FXAA to a framebuffer with linear RGB color will look worse. -This is very counter intuitive, but happends to be true in this case. -The reason is because dithering artifacts will be more visiable -in a linear colorspace. - - ------------------------------------------------------------------------------- - COMPLEX INTEGRATION ------------------------------------------------------------------------------- -Q. What if the engine is blending into RGB before wanting to run FXAA? - -A. In the last opaque pass prior to FXAA, - have the pass write out luma into alpha. - Then blend into RGB only. - FXAA should be able to run ok - assuming the blending pass did not any add aliasing. - This should be the common case for particles and common blending passes. - -============================================================================*/ - -/*============================================================================ - - INTEGRATION KNOBS - -============================================================================*/ -// -// FXAA_PS3 and FXAA_360 choose the console algorithm (FXAA3 CONSOLE). -// FXAA_360_OPT is a prototype for the new optimized 360 version. -// -// 1 = Use API. -// 0 = Don't use API. -// -/*--------------------------------------------------------------------------*/ -#ifndef FXAA_PS3 - #define FXAA_PS3 0 -#endif -/*--------------------------------------------------------------------------*/ -#ifndef FXAA_360 - #define FXAA_360 0 -#endif -/*--------------------------------------------------------------------------*/ -#ifndef FXAA_360_OPT - #define FXAA_360_OPT 0 -#endif -/*==========================================================================*/ -#ifndef FXAA_PC - // - // FXAA Quality - // The high quality PC algorithm. - // - #define FXAA_PC 0 -#endif -/*--------------------------------------------------------------------------*/ -#ifndef FXAA_PC_CONSOLE - // - // The console algorithm for PC is included - // for developers targeting really low spec machines. - // - #define FXAA_PC_CONSOLE 0 -#endif -/*--------------------------------------------------------------------------*/ -#ifndef FXAA_GLSL_120 - #define FXAA_GLSL_120 0 -#endif -/*--------------------------------------------------------------------------*/ -#ifndef FXAA_GLSL_130 - #define FXAA_GLSL_130 0 -#endif -/*--------------------------------------------------------------------------*/ -#ifndef FXAA_HLSL_3 - #define FXAA_HLSL_3 0 -#endif -/*--------------------------------------------------------------------------*/ -#ifndef FXAA_HLSL_4 - #define FXAA_HLSL_4 0 -#endif -/*--------------------------------------------------------------------------*/ -#ifndef FXAA_HLSL_5 - #define FXAA_HLSL_5 0 -#endif -/*==========================================================================*/ -#ifndef FXAA_EARLY_EXIT - // - // Controls algorithm's early exit path. - // On PS3 turning this on adds 2 cycles to the shader. - // On 360 turning this off adds 10ths of a millisecond to the shader. - // Turning this off on console will result in a more blurry image. - // So this defaults to on. - // - // 1 = On. - // 0 = Off. - // - #define FXAA_EARLY_EXIT 1 -#endif -/*--------------------------------------------------------------------------*/ -#ifndef FXAA_DISCARD - // - // Only valid for PC OpenGL currently. - // - // 1 = Use discard on pixels which don't need AA. - // For APIs which enable concurrent TEX+ROP from same surface. - // 0 = Return unchanged color on pixels which don't need AA. - // - #define FXAA_DISCARD 0 -#endif -/*--------------------------------------------------------------------------*/ -#ifndef FXAA_FAST_PIXEL_OFFSET - // - // Used for GLSL 120 only. - // - // 1 = GL API supports fast pixel offsets - // 0 = do not use fast pixel offsets - // - #ifdef GL_EXT_gpu_shader4 - #define FXAA_FAST_PIXEL_OFFSET 1 - #endif - #ifdef GL_NV_gpu_shader5 - #define FXAA_FAST_PIXEL_OFFSET 1 - #endif - #ifdef GL_ARB_gpu_shader5 - #define FXAA_FAST_PIXEL_OFFSET 1 - #endif - #ifndef FXAA_FAST_PIXEL_OFFSET - #define FXAA_FAST_PIXEL_OFFSET 0 - #endif -#endif -/*--------------------------------------------------------------------------*/ -#ifndef FXAA_GATHER4_ALPHA - // - // 1 = API supports gather4 on alpha channel. - // 0 = API does not support gather4 on alpha channel. - // - #if (FXAA_HLSL_5 == 1) - #define FXAA_GATHER4_ALPHA 1 - #endif - #ifdef GL_ARB_gpu_shader5 - #define FXAA_GATHER4_ALPHA 1 - #endif - #ifdef GL_NV_gpu_shader5 - #define FXAA_GATHER4_ALPHA 1 - #endif - #ifndef FXAA_GATHER4_ALPHA - #define FXAA_GATHER4_ALPHA 0 - #endif -#endif - -/*============================================================================ - FXAA CONSOLE - TUNING KNOBS -============================================================================*/ -#ifndef FXAA_CONSOLE_EDGE_SHARPNESS - // - // Consoles the sharpness of edges. - // - // Due to the PS3 being ALU bound, - // there are only two safe values here: 4 and 8. - // These options use the shaders ability to a free *|/ by 4|8. - // - // 8.0 is sharper - // 4.0 is softer - // 2.0 is really soft (good for vector graphics inputs) - // - #if 1 - #define FXAA_CONSOLE_EDGE_SHARPNESS 8.0 - #endif - #if 0 - #define FXAA_CONSOLE_EDGE_SHARPNESS 4.0 - #endif - #if 0 - #define FXAA_CONSOLE_EDGE_SHARPNESS 2.0 - #endif -#endif -/*--------------------------------------------------------------------------*/ -#ifndef FXAA_CONSOLE_EDGE_THRESHOLD - // - // The minimum amount of local contrast required to apply algorithm. - // The console setting has a different mapping than the quality setting. - // - // This only applies when FXAA_EARLY_EXIT is 1. - // - // Due to the PS3 being ALU bound, - // there are only two safe values here: 0.25 and 0.125. - // These options use the shaders ability to a free *|/ by 4|8. - // - // 0.125 leaves less aliasing, but is softer - // 0.25 leaves more aliasing, and is sharper - // - #if 1 - #define FXAA_CONSOLE_EDGE_THRESHOLD 0.125 - #else - #define FXAA_CONSOLE_EDGE_THRESHOLD 0.25 - #endif -#endif -/*--------------------------------------------------------------------------*/ -#ifndef FXAA_CONSOLE_EDGE_THRESHOLD_MIN - // - // Trims the algorithm from processing darks. - // The console setting has a different mapping than the quality setting. - // - // This only applies when FXAA_EARLY_EXIT is 1. - // - // This does not apply to PS3. - // PS3 was simplified to avoid more shader instructions. - // - #define FXAA_CONSOLE_EDGE_THRESHOLD_MIN 0.05 -#endif - -/*============================================================================ - FXAA QUALITY - TUNING KNOBS -============================================================================*/ -#ifndef FXAA_QUALITY_EDGE_THRESHOLD - // - // The minimum amount of local contrast required to apply algorithm. - // - // 1/3 - too little - // 1/4 - low quality - // 1/6 - default - // 1/8 - high quality (default) - // 1/16 - overkill - // - #define FXAA_QUALITY_EDGE_THRESHOLD (1.0/6.0) -#endif -/*--------------------------------------------------------------------------*/ -#ifndef FXAA_QUALITY_EDGE_THRESHOLD_MIN - // - // Trims the algorithm from processing darks. - // - // 1/32 - visible limit - // 1/16 - high quality - // 1/12 - upper limit (default, the start of visible unfiltered edges) - // - #define FXAA_QUALITY_EDGE_THRESHOLD_MIN (1.0/12.0) -#endif -/*--------------------------------------------------------------------------*/ -#ifndef FXAA_QUALITY_SUBPIX - // - // Choose the amount of sub-pixel aliasing removal. - // - // 1 - upper limit (softer) - // 3/4 - default amount of filtering - // 1/2 - lower limit (sharper, less sub-pixel aliasing removal) - // - #define FXAA_QUALITY_SUBPIX (3.0/4.0) -#endif -/*--------------------------------------------------------------------------*/ -#ifndef FXAA_QUALITY_PRESET - // - // Choose the quality preset. - // - // 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 then 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 - - - -/*============================================================================ - - API PORTING - -============================================================================*/ -#if (FXAA_GLSL_120 == 1) - // Requires, - // #version 120 - // And at least, - // #extension GL_EXT_gpu_shader4 : enable - // (or set FXAA_FAST_PIXEL_OFFSET 1 to work like DX9) - #define half float - #define half2 vec2 - #define half3 vec3 - #define half4 vec4 - #define int2 ivec2 - #define float2 vec2 - #define float3 vec3 - #define float4 vec4 - #define FxaaInt2 ivec2 - #define FxaaFloat2 vec2 - #define FxaaFloat3 vec3 - #define FxaaFloat4 vec4 - #define FxaaDiscard discard - #define FxaaDot3(a, b) dot(a, b) - #define FxaaSat(x) clamp(x, 0.0, 1.0) - #define FxaaLerp(x,y,s) mix(x,y,s) - #define FxaaTex sampler2D - #define FxaaTexTop(t, p) texture2DLod(t, p, 0.0) - #if (FXAA_FAST_PIXEL_OFFSET == 1) - #define FxaaTexOff(t, p, o, r) texture2DLodOffset(t, p, 0.0, o) - #else - #define FxaaTexOff(t, p, o, r) texture2DLod(t, p + (o * r), 0.0) - #endif - #if (FXAA_GATHER4_ALPHA == 1) - // use #extension GL_ARB_gpu_shader5 : enable - #define FxaaTexAlpha4(t, p, r) textureGather(t, p, 3) - #define FxaaTexOffAlpha4(t, p, o, r) textureGatherOffset(t, p, o, 3) - #endif -#endif -/*--------------------------------------------------------------------------*/ -#if (FXAA_GLSL_130 == 1) - // Requires "#version 130" or better - #define half float - #define half2 vec2 - #define half3 vec3 - #define half4 vec4 - #define int2 ivec2 - #define float2 vec2 - #define float3 vec3 - #define float4 vec4 - #define FxaaInt2 ivec2 - #define FxaaFloat2 vec2 - #define FxaaFloat3 vec3 - #define FxaaFloat4 vec4 - #define FxaaDiscard discard - #define FxaaDot3(a, b) dot(a, b) - #define FxaaSat(x) clamp(x, 0.0, 1.0) - #define FxaaLerp(x,y,s) mix(x,y,s) - #define FxaaTex sampler2D - #define FxaaTexTop(t, p) textureLod(t, p, 0.0) - #define FxaaTexOff(t, p, o, r) textureLodOffset(t, p, 0.0, o) - #if (FXAA_GATHER4_ALPHA == 1) - // use #extension GL_ARB_gpu_shader5 : enable - #define FxaaTexAlpha4(t, p, r) textureGather(t, p, 3) - #define FxaaTexOffAlpha4(t, p, o, r) textureGatherOffset(t, p, o, 3) - #endif -#endif -/*--------------------------------------------------------------------------*/ -#if (FXAA_HLSL_3 == 1) || (FXAA_360 == 1) - #define int2 float2 - #define FxaaInt2 float2 - #define FxaaFloat2 float2 - #define FxaaFloat3 float3 - #define FxaaFloat4 float4 - #define FxaaDiscard clip(-1) - #define FxaaDot3(a, b) dot(a, b) - #define FxaaSat(x) saturate(x) - #define FxaaLerp(x,y,s) lerp(x,y,s) - #define FxaaTex sampler2D - #define FxaaTexTop(t, p) tex2Dlod(t, float4(p, 0.0, 0.0)) - #define FxaaTexOff(t, p, o, r) tex2Dlod(t, float4(p + (o * r), 0, 0)) -#endif -/*--------------------------------------------------------------------------*/ -#if (FXAA_HLSL_4 == 1) - #define FxaaInt2 int2 - #define FxaaFloat2 float2 - #define FxaaFloat3 float3 - #define FxaaFloat4 float4 - #define FxaaDiscard clip(-1) - #define FxaaDot3(a, b) dot(a, b) - #define FxaaSat(x) saturate(x) - #define FxaaLerp(x,y,s) lerp(x,y,s) - struct FxaaTex { SamplerState smpl; Texture2D tex; }; - #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0) - #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o) -#endif -/*--------------------------------------------------------------------------*/ -#if (FXAA_HLSL_5 == 1) - #define FxaaInt2 int2 - #define FxaaFloat2 float2 - #define FxaaFloat3 float3 - #define FxaaFloat4 float4 - #define FxaaDiscard clip(-1) - #define FxaaDot3(a, b) dot(a, b) - #define FxaaSat(x) saturate(x) - #define FxaaLerp(x,y,s) lerp(x,y,s) - struct FxaaTex { SamplerState smpl; Texture2D tex; }; - #define FxaaTexTop(t, p) t.tex.SampleLevel(t.smpl, p, 0.0) - #define FxaaTexOff(t, p, o, r) t.tex.SampleLevel(t.smpl, p, 0.0, o) - #define FxaaTexAlpha4(t, p, r) t.tex.GatherAlpha(t.smpl, p) - #define FxaaTexOffAlpha4(t, p, o, r) t.tex.GatherAlpha(t.smpl, p, o) -#endif - - - -/*============================================================================ - - FXAA3 QUALITY - PC - -============================================================================*/ -#if (FXAA_PC == 1) -/*--------------------------------------------------------------------------*/ -float4 FxaaPixelShader( - // {xy} = center of pixel - float2 pos, - // {xyzw} = not used on FXAA3 Quality - float4 posPos, - // {rgb_} = color in linear or perceptual color space - // {___a} = luma in perceptual color space (not linear) - FxaaTex tex, - // This must be from a constant/uniform. - // {x_} = 1.0/screenWidthInPixels - // {_y} = 1.0/screenHeightInPixels - float2 rcpFrame, - // {xyzw} = not used on FXAA3 Quality - float4 rcpFrameOpt -) { -/*--------------------------------------------------------------------------*/ - float2 posM; - posM.x = pos.x; - posM.y = pos.y; - #if (FXAA_GATHER4_ALPHA == 1) - #if (FXAA_DISCARD == 0) - float4 rgbyM = FxaaTexTop(tex, posM); - #define lumaM rgbyM.w - #endif - float4 luma4A = FxaaTexAlpha4(tex, posM, rcpFrame.xy); - float4 luma4B = FxaaTexOffAlpha4(tex, posM, FxaaInt2(-1, -1), rcpFrame.xy); - #if (FXAA_DISCARD == 1) - #define lumaM luma4A.w - #endif - #define lumaE luma4A.z - #define lumaS luma4A.x - #define lumaSE luma4A.y - #define lumaNW luma4B.w - #define lumaN luma4B.z - #define lumaW luma4B.x - #else - float4 rgbyM = FxaaTexTop(tex, posM); - #define lumaM rgbyM.w - float lumaS = FxaaTexOff(tex, posM, FxaaInt2( 0, 1), rcpFrame.xy).w; - float lumaE = FxaaTexOff(tex, posM, FxaaInt2( 1, 0), rcpFrame.xy).w; - float lumaN = FxaaTexOff(tex, posM, FxaaInt2( 0,-1), rcpFrame.xy).w; - float lumaW = FxaaTexOff(tex, posM, FxaaInt2(-1, 0), rcpFrame.xy).w; - #endif -/*--------------------------------------------------------------------------*/ - 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 * FXAA_QUALITY_EDGE_THRESHOLD; - float range = rangeMax - rangeMin; - float rangeMaxClamped = max(FXAA_QUALITY_EDGE_THRESHOLD_MIN, rangeMaxScaled); - bool earlyExit = range < rangeMaxClamped; -/*--------------------------------------------------------------------------*/ - if(earlyExit) - #if (FXAA_DISCARD == 1) - FxaaDiscard; - #else - return rgbyM; - #endif -/*--------------------------------------------------------------------------*/ - #if (FXAA_GATHER4_ALPHA == 0) - float lumaNW = FxaaTexOff(tex, posM, FxaaInt2(-1,-1), rcpFrame.xy).w; - float lumaSE = FxaaTexOff(tex, posM, FxaaInt2( 1, 1), rcpFrame.xy).w; - float lumaNE = FxaaTexOff(tex, posM, FxaaInt2( 1,-1), rcpFrame.xy).w; - float lumaSW = FxaaTexOff(tex, posM, FxaaInt2(-1, 1), rcpFrame.xy).w; - #else - float lumaNE = FxaaTexOff(tex, posM, FxaaInt2(1, -1), rcpFrame.xy).w; - float lumaSW = FxaaTexOff(tex, posM, FxaaInt2(-1, 1), rcpFrame.xy).w; - #endif -/*--------------------------------------------------------------------------*/ - 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 = rcpFrame.x; - bool horzSpan = edgeHorz >= edgeVert; - float subpixA = subpixNSWE * 2.0 + subpixNWSWNESE; -/*--------------------------------------------------------------------------*/ - if(!horzSpan) lumaN = lumaW; - if(!horzSpan) lumaS = lumaE; - if(horzSpan) lengthSign = rcpFrame.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); -/*--------------------------------------------------------------------------*/ - float2 posB; - posB.x = posM.x; - posB.y = posM.y; - float2 offNP; - offNP.x = (!horzSpan) ? 0.0 : rcpFrame.x; - offNP.y = ( horzSpan) ? 0.0 : rcpFrame.y; - if(!horzSpan) posB.x += lengthSign * 0.5; - if( horzSpan) posB.y += lengthSign * 0.5; -/*--------------------------------------------------------------------------*/ - float2 posN; - posN.x = posB.x - offNP.x * FXAA_QUALITY_P0; - posN.y = posB.y - offNP.y * FXAA_QUALITY_P0; - float2 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 = FxaaTexTop(tex, posN).w; - float subpixE = subpixC * subpixC; - float lumaEndP = FxaaTexTop(tex, posP).w; -/*--------------------------------------------------------------------------*/ - 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 = FxaaTexTop(tex, posN.xy).w; - if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w; - 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 = FxaaTexTop(tex, posN.xy).w; - if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w; - 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 = FxaaTexTop(tex, posN.xy).w; - if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w; - 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 = FxaaTexTop(tex, posN.xy).w; - if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w; - 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 = FxaaTexTop(tex, posN.xy).w; - if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w; - 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 = FxaaTexTop(tex, posN.xy).w; - if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w; - 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 = FxaaTexTop(tex, posN.xy).w; - if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w; - 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 = FxaaTexTop(tex, posN.xy).w; - if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w; - 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 = FxaaTexTop(tex, posN.xy).w; - if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w; - 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 = FxaaTexTop(tex, posN.xy).w; - if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w; - 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 = FxaaTexTop(tex, posN.xy).w; - if(!doneP) lumaEndP = FxaaTexTop(tex, posP.xy).w; - 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 * FXAA_QUALITY_SUBPIX; -/*--------------------------------------------------------------------------*/ - float pixelOffsetGood = goodSpan ? pixelOffset : 0.0; - float pixelOffsetSubpix = max(pixelOffsetGood, subpixH); - if(!horzSpan) posM.x += pixelOffsetSubpix * lengthSign; - if( horzSpan) posM.y += pixelOffsetSubpix * lengthSign; - #if (FXAA_DISCARD == 1) - return FxaaTexTop(tex, posM); - #else - return float4(FxaaTexTop(tex, posM).xyz, lumaM); - #endif -} -/*==========================================================================*/ -#endif - -#ifdef SHADER_MODEL -PS_OUTPUT ps_main(PS_INPUT input) -{ - PS_OUTPUT output; - - float2 pos = input.t; - float4 posPos = (float4)0; - - FxaaTex tex; - - #if SHADER_MODEL >= 0x400 - - tex.tex = Texture; - tex.smpl = TextureSampler; - - #else - - tex = Texture; - - #endif - - output.c = FxaaPixelShader(pos, posPos, tex, _rcpFrame.xy, _rcpFrameOpt); - - return output; -} -#endif - -#if (FXAA_GLSL_130 == 1) -void ps_main() -{ - vec2 pos = PSin_t; - vec4 posPos = vec4(0.0, 0.0, 0.0, 0.0); - - SV_Target0 = FxaaPixelShader(pos, posPos, TextureSampler, _rcpFrame.xy, _rcpFrameOpt); -} -#endif - -#endif