Added FXAA post-processing

Implementation of Fast Approximate Anti-Aliasing is based on nVidia sample:
https://github.com/NVIDIAGameWorks/GraphicsSamples/tree/master/samples/es3-kepler/FXAA

docs/licenses/fxaa.txt

@@ -0,0 +1,33 @@
+//----------------------------------------------------------------------------------
+// File:        es3-kepler\FXAA/FXAA3_11.h
+// SDK Version: v3.00 
+// Email:       gameworks@nvidia.com
+// Site:        http://developer.nvidia.com/
+//
+// Copyright (c) 2014-2015, NVIDIA CORPORATION. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//  * Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//  * Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+//  * Neither the name of NVIDIA CORPORATION nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+//----------------------------------------------------------------------------------

src/CMakeLists.txt

@@ -1131,6 +1131,7 @@ set( FASTMATH_SOURCES
 	gl/shaders/gl_colormapshader.cpp
 	gl/shaders/gl_tonemapshader.cpp
 	gl/shaders/gl_lensshader.cpp
+	gl/shaders/gl_fxaashader.cpp
 	gl/system/gl_interface.cpp
 	gl/system/gl_framebuffer.cpp
 	gl/system/gl_debug.cpp

src/gl/renderer/gl_postprocess.cpp

@@ -60,6 +60,7 @@
 #include "gl/shaders/gl_tonemapshader.h"
 #include "gl/shaders/gl_colormapshader.h"
 #include "gl/shaders/gl_lensshader.h"
+#include "gl/shaders/gl_fxaashader.h"
 #include "gl/shaders/gl_presentshader.h"
 #include "gl/renderer/gl_2ddrawer.h"
 #include "gl/stereo3d/gl_stereo3d.h"
@@ -98,6 +99,14 @@ CVAR(Float, gl_lens_k, -0.12f, CVAR_ARCHIVE | CVAR_GLOBALCONFIG)
 CVAR(Float, gl_lens_kcube, 0.1f, CVAR_ARCHIVE | CVAR_GLOBALCONFIG)
 CVAR(Float, gl_lens_chromatic, 1.12f, CVAR_ARCHIVE | CVAR_GLOBALCONFIG)
 
+CUSTOM_CVAR(Int, gl_fxaa, 0, CVAR_ARCHIVE | CVAR_GLOBALCONFIG)
+{
+	if (self < 0 || self >= FFXAAShader::Count)
+	{
+		self = 0;
+	}
+}
+
 EXTERN_CVAR(Float, vid_brightness)
 EXTERN_CVAR(Float, vid_contrast)
 
@@ -447,6 +456,51 @@ void FGLRenderer::LensDistortScene()
 	FGLDebug::PopGroup();
 }
 
+//-----------------------------------------------------------------------------
+//
+// Apply FXAA and place the result in the HUD/2D texture
+//
+//-----------------------------------------------------------------------------
+
+void FGLRenderer::ApplyFXAA()
+{
+	if (0 == gl_fxaa)
+	{
+		return;
+	}
+
+	FGLDebug::PushGroup("ApplyFXAA");
+
+	const GLfloat rpcRes[2] =
+	{
+		1.0f / mBuffers->GetWidth(),
+		1.0f / mBuffers->GetHeight()
+	};
+
+	FGLPostProcessState savedState;
+
+	mBuffers->BindNextFB();
+	mBuffers->BindCurrentTexture(0);
+	mFXAALumaShader->Bind();
+	mFXAALumaShader->InputTexture.Set(0);
+	RenderScreenQuad();
+	mBuffers->NextTexture();
+
+	mBuffers->BindNextFB();
+	mBuffers->BindCurrentTexture(0);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	mFXAAShader->Bind();
+	mFXAAShader->InputTexture.Set(0);
+	mFXAAShader->ReciprocalResolution.Set(rpcRes);
+	RenderScreenQuad();
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+	mBuffers->NextTexture();
+
+	FGLDebug::PopGroup();
+}
+
 //-----------------------------------------------------------------------------
 //
 // Copies the rendered screen to its final destination

src/gl/renderer/gl_renderer.cpp

@@ -56,6 +56,7 @@
 #include "gl/shaders/gl_tonemapshader.h"
 #include "gl/shaders/gl_colormapshader.h"
 #include "gl/shaders/gl_lensshader.h"
+#include "gl/shaders/gl_fxaashader.h"
 #include "gl/shaders/gl_presentshader.h"
 #include "gl/shaders/gl_present3dRowshader.h"
 #include "gl/stereo3d/gl_stereo3d.h"
@@ -115,6 +116,8 @@ FGLRenderer::FGLRenderer(OpenGLFrameBuffer *fb)
 	mTonemapPalette = nullptr;
 	mColormapShader = nullptr;
 	mLensShader = nullptr;
+	mFXAAShader = nullptr;
+	mFXAALumaShader = nullptr;
 }
 
 void gl_LoadModels();
@@ -133,6 +136,8 @@ void FGLRenderer::Initialize(int width, int height)
 	mColormapShader = new FColormapShader();
 	mTonemapPalette = nullptr;
 	mLensShader = new FLensShader();
+	mFXAAShader = new FFXAAShader;
+	mFXAALumaShader = new FFXAALumaShader;
 	mPresentShader = new FPresentShader();
 	mPresent3dRowShader = new FPresent3DRowShader();
 	m2DDrawer = new F2DDrawer;
@@ -198,6 +203,8 @@ FGLRenderer::~FGLRenderer()
 	if (mTonemapPalette) delete mTonemapPalette;
 	if (mColormapShader) delete mColormapShader;
 	if (mLensShader) delete mLensShader;
+	delete mFXAAShader;
+	delete mFXAALumaShader;
 }
 
 //==========================================================================

src/gl/renderer/gl_renderer.h

@@ -28,6 +28,8 @@ class FBlurShader;
 class FTonemapShader;
 class FColormapShader;
 class FLensShader;
+class FFXAALumaShader;
+class FFXAAShader;
 class FPresentShader;
 class FPresent3DRowShader;
 class F2DDrawer;
@@ -104,6 +106,8 @@ public:
 	FColormapShader *mColormapShader;
 	FHardwareTexture *mTonemapPalette;
 	FLensShader *mLensShader;
+	FFXAALumaShader *mFXAALumaShader;
+	FFXAAShader *mFXAAShader;
 	FPresentShader *mPresentShader;
 	FPresent3DRowShader *mPresent3dRowShader;
 
@@ -180,6 +184,7 @@ public:
 	void BindTonemapPalette(int texunit);
 	void ClearTonemapPalette();
 	void LensDistortScene();
+	void ApplyFXAA();
 	void CopyToBackbuffer(const GL_IRECT *bounds, bool applyGamma);
 	void DrawPresentTexture(const GL_IRECT &box, bool applyGamma);
 	void Flush();

src/gl/scene/gl_scene.cpp

@@ -832,6 +832,7 @@ sector_t * FGLRenderer::RenderViewpoint (AActor * camera, GL_IRECT * bounds, flo
 			TonemapScene();
 			ColormapScene();
 			LensDistortScene();
+			ApplyFXAA();
 
 			// This should be done after postprocessing, not before.
 			mBuffers->BindCurrentFB();

src/gl/shaders/gl_fxaashader.cpp

@@ -0,0 +1,99 @@
+//
+//---------------------------------------------------------------------------
+//
+// Copyright(C) 2016 Alexey Lysiuk
+// All rights reserved.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/
+//
+//--------------------------------------------------------------------------
+//
+
+//
+// Fast approXimate Anti-Aliasing (FXAA) post-processing
+//
+
+#include "gl/system/gl_system.h"
+#include "gl/shaders/gl_fxaashader.h"
+
+EXTERN_CVAR(Int, gl_fxaa)
+
+void FFXAALumaShader::Bind()
+{
+	if (!mShader)
+	{
+		mShader.Compile(FShaderProgram::Vertex, "shaders/glsl/screenquad.vp", "", 330);
+		mShader.Compile(FShaderProgram::Fragment, "shaders/glsl/fxaa.fp", "#define FXAA_LUMA_PASS\n", 330);
+		mShader.SetFragDataLocation(0, "FragColor");
+		mShader.Link("shaders/glsl/fxaa");
+		mShader.SetAttribLocation(0, "PositionInProjection");
+		InputTexture.Init(mShader, "InputTexture");
+	}
+
+	mShader.Bind();
+}
+
+static int GetMaxVersion()
+{
+	return gl.glslversion >= 4.f ? 400 : 330;
+}
+
+static FString GetDefines()
+{
+	int quality;
+
+	switch (gl_fxaa)
+	{
+	default:
+	case FFXAAShader::Low:     quality = 10; break;
+	case FFXAAShader::Medium:  quality = 12; break;
+	case FFXAAShader::High:    quality = 29; break;
+	case FFXAAShader::Extreme: quality = 39; break;
+	}
+
+	const int gatherAlpha = GetMaxVersion() >= 400 ? 1 : 0;
+
+	// TODO: enable FXAA_GATHER4_ALPHA on OpenGL earlier than 4.0
+	// when GL_ARB_gpu_shader5/GL_NV_gpu_shader5 extensions are supported
+
+	FString result;
+	result.Format(
+		"#define FXAA_QUALITY__PRESET %i\n"
+		"#define FXAA_GATHER4_ALPHA %i\n",
+		quality, gatherAlpha);
+
+	return result;
+}
+
+void FFXAAShader::Bind()
+{
+	assert(gl_fxaa > 0 && gl_fxaa < Count);
+	FShaderProgram &shader = mShaders[gl_fxaa];
+
+	if (!shader)
+	{
+		const FString defines = GetDefines();
+		const int maxVersion = GetMaxVersion();
+
+		shader.Compile(FShaderProgram::Vertex, "shaders/glsl/screenquad.vp", "", 330);
+		shader.Compile(FShaderProgram::Fragment, "shaders/glsl/fxaa.fp", defines, maxVersion);
+		shader.SetFragDataLocation(0, "FragColor");
+		shader.Link("shaders/glsl/fxaa");
+		shader.SetAttribLocation(0, "PositionInProjection");
+		InputTexture.Init(shader, "InputTexture");
+		ReciprocalResolution.Init(shader, "ReciprocalResolution");
+	}
+
+	shader.Bind();
+}

src/gl/shaders/gl_fxaashader.h

@@ -0,0 +1,66 @@
+// 
+//---------------------------------------------------------------------------
+//
+// Copyright(C) 2016 Alexey Lysiuk
+// All rights reserved.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with this program.  If not, see http://www.gnu.org/licenses/
+//
+//--------------------------------------------------------------------------
+//
+
+//
+// Fast approXimate Anti-Aliasing (FXAA) post-processing
+//
+
+#ifndef __GL_FXAASHADER_H__
+#define __GL_FXAASHADER_H__
+
+#include "gl_shaderprogram.h"
+
+class FFXAALumaShader
+{
+public:
+	void Bind();
+
+	FBufferedUniform1i InputTexture;
+
+private:
+	FShaderProgram mShader;
+};
+
+
+class FFXAAShader
+{
+public:
+	enum Quality
+	{
+		None,
+		Low,
+		Medium,
+		High,
+		Extreme,
+		Count
+	};
+
+	void Bind();
+
+	FBufferedUniform1i InputTexture;
+	FBufferedUniform2f ReciprocalResolution;
+
+private:
+	FShaderProgram mShaders[Count];
+};
+
+#endif // __GL_FXAASHADER_H__

wadsrc/static/language.enu

@@ -2633,6 +2633,7 @@ GLPREFMNU_MULTISAMPLE			= "Multisample";
 GLPREFMNU_TONEMAP				= "Tonemap Mode";
 GLPREFMNU_BLOOM					= "Bloom effect";
 GLPREFMNU_LENS					= "Lens distortion effect";
+GLPREFMNU_FXAA					= "FXAA Quality";
 
 // Option Values
 OPTVAL_SMART 				= "Smart";
@@ -2710,3 +2711,7 @@ OPTVAL_UNCHARTED2			= "Uncharted 2";
 OPTVAL_HEJLDAWSON			= "Hejl Dawson";
 OPTVAL_REINHARD				= "Reinhard";
 OPTVAL_PALETTE				= "Palette";
+OPTVAL_LOW					= "Low";
+OPTVAL_MEDIUM				= "Medium";
+OPTVAL_HIGH					= "High";
+OPTVAL_EXTREME				= "Extreme";

wadsrc/static/menudef.zz

@@ -42,6 +42,15 @@ OptionValue "TonemapModes"
 	5, "$OPTVAL_PALETTE"
 }
 
+OptionValue "FXAAQuality"
+{
+	0, "$OPTVAL_OFF"
+	1, "$OPTVAL_LOW"
+	2, "$OPTVAL_MEDIUM"
+	3, "$OPTVAL_HIGH"
+	4, "$OPTVAL_EXTREME"
+}
+
 OptionValue "TextureFormats"
 {
 	0, "$OPTVAL_RGBA8"
@@ -228,4 +237,5 @@ OptionMenu "GLPrefOptions"
 	Option "$GLPREFMNU_TONEMAP", 				gl_tonemap,						"TonemapModes"
 	Option "$GLPREFMNU_BLOOM",		 			gl_bloom,						"OnOff"
 	Option "$GLPREFMNU_LENS",		 			gl_lens,						"OnOff"
+	Option "$GLPREFMNU_FXAA",		 			gl_fxaa,						"FXAAQuality"
 }

wadsrc/static/shaders/glsl/fxaa.fp

@@ -0,0 +1,615 @@
+//----------------------------------------------------------------------------------
+// File:        es3-kepler\FXAA/FXAA3_11.h
+// SDK Version: v3.00 
+// Email:       gameworks@nvidia.com
+// Site:        http://developer.nvidia.com/
+//
+// Copyright (c) 2014-2015, NVIDIA CORPORATION. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//  * Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//  * Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+//  * Neither the name of NVIDIA CORPORATION nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+//----------------------------------------------------------------------------------
+
+in vec2 TexCoord;
+out vec4 FragColor;
+
+uniform sampler2D InputTexture;
+
+#ifdef FXAA_LUMA_PASS
+
+void main()
+{
+	vec3 tex = texture(InputTexture, TexCoord).rgb;
+	vec3 luma = vec3(0.299, 0.587, 0.114);
+	FragColor = vec4(tex, dot(tex, luma));
+}
+
+#else // FXAA itself
+
+//============================================================================
+//                    NVIDIA FXAA 3.11 by TIMOTHY LOTTES
+//============================================================================
+
+#define FXAA_DISCARD 1
+
+#define FXAA_GREEN_AS_LUMA 0
+
+#define FxaaBool bool
+#define FxaaDiscard discard
+#define FxaaFloat float
+#define FxaaFloat2 vec2
+#define FxaaFloat3 vec3
+#define FxaaFloat4 vec4
+#define FxaaHalf float
+#define FxaaHalf2 vec2
+#define FxaaHalf3 vec3
+#define FxaaHalf4 vec4
+#define FxaaInt2 ivec2
+#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)
+	#define FxaaTexAlpha4(t, p) textureGather(t, p, 3)
+	#define FxaaTexOffAlpha4(t, p, o) textureGatherOffset(t, p, o, 3)
+	#define FxaaTexGreen4(t, p) textureGather(t, p, 1)
+	#define FxaaTexOffGreen4(t, p, o) textureGatherOffset(t, p, o, 1)
+#endif
+
+#if (FXAA_GREEN_AS_LUMA == 0)
+	FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.w; }
+#else
+	FxaaFloat FxaaLuma(FxaaFloat4 rgba) { return rgba.y; }
+#endif
+
+#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
+#elif (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
+#elif (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
+#elif (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
+#elif (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
+#elif (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
+#elif (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
+#elif (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
+#elif (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
+#elif (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
+#elif (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
+#elif (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
+#elif (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
+#elif (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
+#elif (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
+#elif (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
+#elif (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
+
+FxaaFloat4 FxaaPixelShader(FxaaFloat2 pos, FxaaTex tex, FxaaFloat2 fxaaQualityRcpFrame, 
+	FxaaFloat fxaaQualitySubpix, FxaaFloat fxaaQualityEdgeThreshold, FxaaFloat fxaaQualityEdgeThresholdMin)
+{
+	FxaaFloat2 posM;
+	posM.x = pos.x;
+	posM.y = pos.y;
+	#if (FXAA_GATHER4_ALPHA == 1)
+		#if (FXAA_DISCARD == 0)
+			FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);
+			#if (FXAA_GREEN_AS_LUMA == 0)
+				#define lumaM rgbyM.w
+			#else
+				#define lumaM rgbyM.y
+			#endif
+		#endif
+		#if (FXAA_GREEN_AS_LUMA == 0)
+			FxaaFloat4 luma4A = FxaaTexAlpha4(tex, posM);
+			FxaaFloat4 luma4B = FxaaTexOffAlpha4(tex, posM, FxaaInt2(-1, -1));
+		#else
+			FxaaFloat4 luma4A = FxaaTexGreen4(tex, posM);
+			FxaaFloat4 luma4B = FxaaTexOffGreen4(tex, posM, FxaaInt2(-1, -1));
+		#endif
+		#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
+		FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);
+		#if (FXAA_GREEN_AS_LUMA == 0)
+			#define lumaM rgbyM.w
+		#else
+			#define lumaM rgbyM.y
+		#endif
+		FxaaFloat lumaS = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0, 1), fxaaQualityRcpFrame.xy));
+		FxaaFloat lumaE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 0), fxaaQualityRcpFrame.xy));
+		FxaaFloat lumaN = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0,-1), fxaaQualityRcpFrame.xy));
+		FxaaFloat lumaW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 0), fxaaQualityRcpFrame.xy));
+	#endif
+/*--------------------------------------------------------------------------*/
+	FxaaFloat maxSM = max(lumaS, lumaM);
+	FxaaFloat minSM = min(lumaS, lumaM);
+	FxaaFloat maxESM = max(lumaE, maxSM);
+	FxaaFloat minESM = min(lumaE, minSM);
+	FxaaFloat maxWN = max(lumaN, lumaW);
+	FxaaFloat minWN = min(lumaN, lumaW);
+	FxaaFloat rangeMax = max(maxWN, maxESM);
+	FxaaFloat rangeMin = min(minWN, minESM);
+	FxaaFloat rangeMaxScaled = rangeMax * fxaaQualityEdgeThreshold;
+	FxaaFloat range = rangeMax - rangeMin;
+	FxaaFloat rangeMaxClamped = max(fxaaQualityEdgeThresholdMin, rangeMaxScaled);
+	FxaaBool earlyExit = range < rangeMaxClamped;
+/*--------------------------------------------------------------------------*/
+	if(earlyExit)
+		#if (FXAA_DISCARD == 1)
+			FxaaDiscard;
+		#else
+			return rgbyM;
+		#endif
+/*--------------------------------------------------------------------------*/
+	#if (FXAA_GATHER4_ALPHA == 0)
+		FxaaFloat lumaNW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1,-1), fxaaQualityRcpFrame.xy));
+		FxaaFloat lumaSE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 1), fxaaQualityRcpFrame.xy));
+		FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1,-1), fxaaQualityRcpFrame.xy));
+		FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));
+	#else
+		FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(1, -1), fxaaQualityRcpFrame.xy));
+		FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));
+	#endif
+/*--------------------------------------------------------------------------*/
+	FxaaFloat lumaNS = lumaN + lumaS;
+	FxaaFloat lumaWE = lumaW + lumaE;
+	FxaaFloat subpixRcpRange = 1.0/range;
+	FxaaFloat subpixNSWE = lumaNS + lumaWE;
+	FxaaFloat edgeHorz1 = (-2.0 * lumaM) + lumaNS;
+	FxaaFloat edgeVert1 = (-2.0 * lumaM) + lumaWE;
+/*--------------------------------------------------------------------------*/
+	FxaaFloat lumaNESE = lumaNE + lumaSE;
+	FxaaFloat lumaNWNE = lumaNW + lumaNE;
+	FxaaFloat edgeHorz2 = (-2.0 * lumaE) + lumaNESE;
+	FxaaFloat edgeVert2 = (-2.0 * lumaN) + lumaNWNE;
+/*--------------------------------------------------------------------------*/
+	FxaaFloat lumaNWSW = lumaNW + lumaSW;
+	FxaaFloat lumaSWSE = lumaSW + lumaSE;
+	FxaaFloat edgeHorz4 = (abs(edgeHorz1) * 2.0) + abs(edgeHorz2);
+	FxaaFloat edgeVert4 = (abs(edgeVert1) * 2.0) + abs(edgeVert2);
+	FxaaFloat edgeHorz3 = (-2.0 * lumaW) + lumaNWSW;
+	FxaaFloat edgeVert3 = (-2.0 * lumaS) + lumaSWSE;
+	FxaaFloat edgeHorz = abs(edgeHorz3) + edgeHorz4;
+	FxaaFloat edgeVert = abs(edgeVert3) + edgeVert4;
+/*--------------------------------------------------------------------------*/
+	FxaaFloat subpixNWSWNESE = lumaNWSW + lumaNESE;
+	FxaaFloat lengthSign = fxaaQualityRcpFrame.x;
+	FxaaBool horzSpan = edgeHorz >= edgeVert;
+	FxaaFloat subpixA = subpixNSWE * 2.0 + subpixNWSWNESE;
+/*--------------------------------------------------------------------------*/
+	if(!horzSpan) lumaN = lumaW;
+	if(!horzSpan) lumaS = lumaE;
+	if(horzSpan) lengthSign = fxaaQualityRcpFrame.y;
+	FxaaFloat subpixB = (subpixA * (1.0/12.0)) - lumaM;
+/*--------------------------------------------------------------------------*/
+	FxaaFloat gradientN = lumaN - lumaM;
+	FxaaFloat gradientS = lumaS - lumaM;
+	FxaaFloat lumaNN = lumaN + lumaM;
+	FxaaFloat lumaSS = lumaS + lumaM;
+	FxaaBool pairN = abs(gradientN) >= abs(gradientS);
+	FxaaFloat gradient = max(abs(gradientN), abs(gradientS));
+	if(pairN) lengthSign = -lengthSign;
+	FxaaFloat subpixC = FxaaSat(abs(subpixB) * subpixRcpRange);
+/*--------------------------------------------------------------------------*/
+	FxaaFloat2 posB;
+	posB.x = posM.x;
+	posB.y = posM.y;
+	FxaaFloat2 offNP;
+	offNP.x = (!horzSpan) ? 0.0 : fxaaQualityRcpFrame.x;
+	offNP.y = ( horzSpan) ? 0.0 : fxaaQualityRcpFrame.y;
+	if(!horzSpan) posB.x += lengthSign * 0.5;
+	if( horzSpan) posB.y += lengthSign * 0.5;
+/*--------------------------------------------------------------------------*/
+	FxaaFloat2 posN;
+	posN.x = posB.x - offNP.x * FXAA_QUALITY__P0;
+	posN.y = posB.y - offNP.y * FXAA_QUALITY__P0;
+	FxaaFloat2 posP;
+	posP.x = posB.x + offNP.x * FXAA_QUALITY__P0;
+	posP.y = posB.y + offNP.y * FXAA_QUALITY__P0;
+	FxaaFloat subpixD = ((-2.0)*subpixC) + 3.0;
+	FxaaFloat lumaEndN = FxaaLuma(FxaaTexTop(tex, posN));
+	FxaaFloat subpixE = subpixC * subpixC;
+	FxaaFloat lumaEndP = FxaaLuma(FxaaTexTop(tex, posP));
+/*--------------------------------------------------------------------------*/
+	if(!pairN) lumaNN = lumaSS;
+	FxaaFloat gradientScaled = gradient * 1.0/4.0;
+	FxaaFloat lumaMM = lumaM - lumaNN * 0.5;
+	FxaaFloat subpixF = subpixD * subpixE;
+	FxaaBool lumaMLTZero = lumaMM < 0.0;
+/*--------------------------------------------------------------------------*/
+	lumaEndN -= lumaNN * 0.5;
+	lumaEndP -= lumaNN * 0.5;
+	FxaaBool doneN = abs(lumaEndN) >= gradientScaled;
+	FxaaBool doneP = abs(lumaEndP) >= gradientScaled;
+	if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P1;
+	if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P1;
+	FxaaBool doneNP = (!doneN) || (!doneP);
+	if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P1;
+	if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P1;
+/*--------------------------------------------------------------------------*/
+	if(doneNP) {
+		if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+		if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+		if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+		if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+		doneN = abs(lumaEndN) >= gradientScaled;
+		doneP = abs(lumaEndP) >= gradientScaled;
+		if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P2;
+		if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P2;
+		doneNP = (!doneN) || (!doneP);
+		if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P2;
+		if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P2;
+/*--------------------------------------------------------------------------*/
+		#if (FXAA_QUALITY__PS > 3)
+		if(doneNP) {
+			if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+			if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+			if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+			if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+			doneN = abs(lumaEndN) >= gradientScaled;
+			doneP = abs(lumaEndP) >= gradientScaled;
+			if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P3;
+			if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P3;
+			doneNP = (!doneN) || (!doneP);
+			if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P3;
+			if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P3;
+/*--------------------------------------------------------------------------*/
+			#if (FXAA_QUALITY__PS > 4)
+			if(doneNP) {
+				if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+				if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+				if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+				if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+				doneN = abs(lumaEndN) >= gradientScaled;
+				doneP = abs(lumaEndP) >= gradientScaled;
+				if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P4;
+				if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P4;
+				doneNP = (!doneN) || (!doneP);
+				if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P4;
+				if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P4;
+/*--------------------------------------------------------------------------*/
+				#if (FXAA_QUALITY__PS > 5)
+				if(doneNP) {
+					if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+					if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+					if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+					if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+					doneN = abs(lumaEndN) >= gradientScaled;
+					doneP = abs(lumaEndP) >= gradientScaled;
+					if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P5;
+					if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P5;
+					doneNP = (!doneN) || (!doneP);
+					if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P5;
+					if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P5;
+/*--------------------------------------------------------------------------*/
+					#if (FXAA_QUALITY__PS > 6)
+					if(doneNP) {
+						if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+						if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+						if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+						if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+						doneN = abs(lumaEndN) >= gradientScaled;
+						doneP = abs(lumaEndP) >= gradientScaled;
+						if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P6;
+						if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P6;
+						doneNP = (!doneN) || (!doneP);
+						if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P6;
+						if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P6;
+/*--------------------------------------------------------------------------*/
+						#if (FXAA_QUALITY__PS > 7)
+						if(doneNP) {
+							if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+							if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+							if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+							if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+							doneN = abs(lumaEndN) >= gradientScaled;
+							doneP = abs(lumaEndP) >= gradientScaled;
+							if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P7;
+							if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P7;
+							doneNP = (!doneN) || (!doneP);
+							if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P7;
+							if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P7;
+/*--------------------------------------------------------------------------*/
+	#if (FXAA_QUALITY__PS > 8)
+	if(doneNP) {
+		if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+		if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+		if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+		if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+		doneN = abs(lumaEndN) >= gradientScaled;
+		doneP = abs(lumaEndP) >= gradientScaled;
+		if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P8;
+		if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P8;
+		doneNP = (!doneN) || (!doneP);
+		if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P8;
+		if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P8;
+/*--------------------------------------------------------------------------*/
+		#if (FXAA_QUALITY__PS > 9)
+		if(doneNP) {
+			if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+			if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+			if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+			if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+			doneN = abs(lumaEndN) >= gradientScaled;
+			doneP = abs(lumaEndP) >= gradientScaled;
+			if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P9;
+			if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P9;
+			doneNP = (!doneN) || (!doneP);
+			if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P9;
+			if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P9;
+/*--------------------------------------------------------------------------*/
+			#if (FXAA_QUALITY__PS > 10)
+			if(doneNP) {
+				if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+				if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+				if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+				if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+				doneN = abs(lumaEndN) >= gradientScaled;
+				doneP = abs(lumaEndP) >= gradientScaled;
+				if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P10;
+				if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P10;
+				doneNP = (!doneN) || (!doneP);
+				if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P10;
+				if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P10;
+/*--------------------------------------------------------------------------*/
+				#if (FXAA_QUALITY__PS > 11)
+				if(doneNP) {
+					if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+					if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+					if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+					if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+					doneN = abs(lumaEndN) >= gradientScaled;
+					doneP = abs(lumaEndP) >= gradientScaled;
+					if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P11;
+					if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P11;
+					doneNP = (!doneN) || (!doneP);
+					if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P11;
+					if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P11;
+/*--------------------------------------------------------------------------*/
+					#if (FXAA_QUALITY__PS > 12)
+					if(doneNP) {
+						if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
+						if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
+						if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+						if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+						doneN = abs(lumaEndN) >= gradientScaled;
+						doneP = abs(lumaEndP) >= gradientScaled;
+						if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P12;
+						if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P12;
+						doneNP = (!doneN) || (!doneP);
+						if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P12;
+						if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P12;
+/*--------------------------------------------------------------------------*/
+					}
+					#endif
+/*--------------------------------------------------------------------------*/
+				}
+				#endif
+/*--------------------------------------------------------------------------*/
+			}
+			#endif
+/*--------------------------------------------------------------------------*/
+		}
+		#endif
+/*--------------------------------------------------------------------------*/
+	}
+	#endif
+/*--------------------------------------------------------------------------*/
+						}
+						#endif
+/*--------------------------------------------------------------------------*/
+					}
+					#endif
+/*--------------------------------------------------------------------------*/
+				}
+				#endif
+/*--------------------------------------------------------------------------*/
+			}
+			#endif
+/*--------------------------------------------------------------------------*/
+		}
+		#endif
+/*--------------------------------------------------------------------------*/
+	}
+/*--------------------------------------------------------------------------*/
+	FxaaFloat dstN = posM.x - posN.x;
+	FxaaFloat dstP = posP.x - posM.x;
+	if(!horzSpan) dstN = posM.y - posN.y;
+	if(!horzSpan) dstP = posP.y - posM.y;
+/*--------------------------------------------------------------------------*/
+	FxaaBool goodSpanN = (lumaEndN < 0.0) != lumaMLTZero;
+	FxaaFloat spanLength = (dstP + dstN);
+	FxaaBool goodSpanP = (lumaEndP < 0.0) != lumaMLTZero;
+	FxaaFloat spanLengthRcp = 1.0/spanLength;
+/*--------------------------------------------------------------------------*/
+	FxaaBool directionN = dstN < dstP;
+	FxaaFloat dst = min(dstN, dstP);
+	FxaaBool goodSpan = directionN ? goodSpanN : goodSpanP;
+	FxaaFloat subpixG = subpixF * subpixF;
+	FxaaFloat pixelOffset = (dst * (-spanLengthRcp)) + 0.5;
+	FxaaFloat subpixH = subpixG * fxaaQualitySubpix;
+/*--------------------------------------------------------------------------*/
+	FxaaFloat pixelOffsetGood = goodSpan ? pixelOffset : 0.0;
+	FxaaFloat 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 FxaaFloat4(FxaaTexTop(tex, posM).xyz, lumaM);
+	#endif
+}
+
+uniform vec2 ReciprocalResolution;
+
+void main()
+{
+	FragColor = FxaaPixelShader(TexCoord, InputTexture, ReciprocalResolution, 0.75f, 0.166f, 0.0833f);
+}
+
+#endif // FXAA_LUMA_PASS