Merge http://github.com/coelckers/gzdoom

# Conflicts:
#	src/gl/renderer/gl_postprocess.cpp
#	src/gl/renderer/gl_renderer.cpp
#	src/gl/scene/gl_scene.cpp
#	wadsrc/static/language.enu
#	wadsrc/static/menudef.zz

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

@@ -1119,6 +1119,7 @@ set( FASTMATH_SOURCES
 	gl/stereo3d/gl_anaglyph.cpp
 	gl/stereo3d/gl_quadstereo.cpp
 	gl/stereo3d/gl_sidebyside3d.cpp
+	gl/stereo3d/gl_interleaved3d.cpp
 	gl/dynlights/gl_dynlight.cpp
 	gl/dynlights/gl_glow.cpp
 	gl/dynlights/gl_dynlight1.cpp
@@ -1127,12 +1128,14 @@ set( FASTMATH_SOURCES
 	gl/shaders/gl_texshader.cpp
 	gl/shaders/gl_shaderprogram.cpp
 	gl/shaders/gl_presentshader.cpp
+	gl/shaders/gl_present3dRowshader.cpp
 	gl/shaders/gl_bloomshader.cpp
 	gl/shaders/gl_ambientshader.cpp
 	gl/shaders/gl_blurshader.cpp
 	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

@@ -61,6 +61,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"
@@ -109,6 +110,14 @@ CUSTOM_CVAR(Float, gl_ssao_blur_amount, 4.0f, 0)
 	if (self < 0.1f) self = 0.1f;
 }
 
+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)
 
@@ -588,6 +597,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_renderbuffers.h

@@ -2,6 +2,7 @@
 #define __GL_RENDERBUFFERS_H
 
 #include "gl/shaders/gl_shader.h"
+#include "gl/renderer/gl_renderer.h"
 
 class FGLBloomTextureLevel
 {

src/gl/renderer/gl_renderer.cpp

@@ -57,7 +57,9 @@
 #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"
 #include "gl/textures/gl_texture.h"
 #include "gl/textures/gl_translate.h"
@@ -104,6 +106,7 @@ FGLRenderer::FGLRenderer(OpenGLFrameBuffer *fb)
 	mTonemapPalette = nullptr;
 	mBuffers = nullptr;
 	mPresentShader = nullptr;
+	mPresent3dRowShader = nullptr;
 	mBloomExtractShader = nullptr;
 	mBloomCombineShader = nullptr;
 	mExposureExtractShader = nullptr;
@@ -114,10 +117,13 @@ FGLRenderer::FGLRenderer(OpenGLFrameBuffer *fb)
 	mTonemapPalette = nullptr;
 	mColormapShader = nullptr;
 	mLensShader = nullptr;
+	mFXAAShader = nullptr;
+	mFXAALumaShader = nullptr;
 	mLinearDepthShader = nullptr;
 	mDepthBlurShader = nullptr;
 	mSSAOShader = nullptr;
 	mSSAOCombineShader = nullptr;
+
 }
 
 void gl_LoadModels();
@@ -140,7 +146,10 @@ 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;
 
 	// needed for the core profile, because someone decided it was a good idea to remove the default VAO.
@@ -193,6 +202,7 @@ FGLRenderer::~FGLRenderer()
 	}
 	if (mBuffers) delete mBuffers;
 	if (mPresentShader) delete mPresentShader;
+	if (mPresent3dRowShader) delete mPresent3dRowShader;
 	if (mLinearDepthShader) delete mLinearDepthShader;
 	if (mDepthBlurShader) delete mDepthBlurShader;
 	if (mSSAOShader) delete mSSAOShader;
@@ -207,6 +217,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

@@ -32,7 +32,10 @@ class FBlurShader;
 class FTonemapShader;
 class FColormapShader;
 class FLensShader;
+class FFXAALumaShader;
+class FFXAAShader;
 class FPresentShader;
+class FPresent3DRowShader;
 class F2DDrawer;
 class FHardwareTexture;
 
@@ -111,7 +114,10 @@ public:
 	FColormapShader *mColormapShader;
 	FHardwareTexture *mTonemapPalette;
 	FLensShader *mLensShader;
+	FFXAALumaShader *mFXAALumaShader;
+	FFXAAShader *mFXAAShader;
 	FPresentShader *mPresentShader;
+	FPresent3DRowShader *mPresent3dRowShader;
 
 	FTexture *gllight;
 	FTexture *glpart2;
@@ -188,6 +194,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

@@ -854,6 +854,7 @@ sector_t * FGLRenderer::RenderViewpoint (AActor * camera, GL_IRECT * bounds, flo
 		if (mainview && FGLRenderBuffers::IsEnabled())
 		{
 			PostProcessScene();
+			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__

src/gl/shaders/gl_present3dRowshader.cpp

@@ -0,0 +1,60 @@
+// 
+//---------------------------------------------------------------------------
+//
+// Copyright(C) 2016 Christopher Bruns
+// 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/
+//
+//--------------------------------------------------------------------------
+//
+/*
+** gl_3dRowshader.cpp
+** Copy rendered texture to back buffer, possibly with gamma correction
+** while interleaving rows from two independent viewpoint textures,
+** representing the left-eye and right-eye views.
+**
+*/
+
+#include "gl/system/gl_system.h"
+#include "files.h"
+#include "m_swap.h"
+#include "v_video.h"
+#include "gl/gl_functions.h"
+#include "vectors.h"
+#include "gl/system/gl_interface.h"
+#include "gl/system/gl_framebuffer.h"
+#include "gl/system/gl_cvars.h"
+#include "gl/shaders/gl_present3dRowshader.h"
+
+void FPresent3DRowShader::Bind()
+{
+	if (!mShader)
+	{
+		mShader.Compile(FShaderProgram::Vertex, "shaders/glsl/screenquadscale.vp", "", 330);
+		mShader.Compile(FShaderProgram::Fragment, "shaders/glsl/present_row3d.fp", "", 330);
+		mShader.SetFragDataLocation(0, "FragColor");
+		mShader.Link("shaders/glsl/presentRow3d");
+		mShader.SetAttribLocation(0, "PositionInProjection");
+		mShader.SetAttribLocation(1, "UV");
+		LeftEyeTexture.Init(mShader, "LeftEyeTexture");
+		RightEyeTexture.Init(mShader, "RightEyeTexture");
+		InvGamma.Init(mShader, "InvGamma");
+		Contrast.Init(mShader, "Contrast");
+		Brightness.Init(mShader, "Brightness");
+		Scale.Init(mShader, "UVScale");
+		VerticalPixelOffset.Init(mShader, "VerticalPixelOffset");
+	}
+	mShader.Bind();
+}

src/gl/shaders/gl_present3dRowshader.h

@@ -0,0 +1,51 @@
+// 
+//---------------------------------------------------------------------------
+//
+// Copyright(C) 2015 Christopher Bruns
+// 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/
+//
+//--------------------------------------------------------------------------
+//
+/*
+** gl_present3dRowshader.h
+** Final composition and present shader for row-interleaved stereoscopic 3D mode
+**
+*/
+
+#ifndef GL_PRESENT3DROWSHADER_H_
+#define GL_PRESENT3DROWSHADER_H_
+
+#include "gl_shaderprogram.h"
+
+class FPresent3DRowShader
+{
+public:
+	void Bind();
+
+	FBufferedUniformSampler LeftEyeTexture;
+	FBufferedUniformSampler RightEyeTexture;
+	FBufferedUniform1f InvGamma;
+	FBufferedUniform1f Contrast;
+	FBufferedUniform1f Brightness;
+	FBufferedUniform2f Scale;
+	FBufferedUniform1i VerticalPixelOffset;
+
+private:
+	FShaderProgram mShader;
+};
+
+// GL_PRESENT3DROWSHADER_H_
+#endif

src/gl/stereo3d/gl_interleaved3d.cpp

@@ -0,0 +1,121 @@
+/*
+** gl_interleaved3d.cpp
+** Interleaved image stereoscopic 3D modes for GZDoom
+**
+**---------------------------------------------------------------------------
+** Copyright 2016 Christopher Bruns
+** All rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+**
+** 1. Redistributions of source code must retain the above copyright
+**    notice, this list of conditions and the following disclaimer.
+** 2. 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.
+** 3. The name of the author may not be used to endorse or promote products
+**    derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+**---------------------------------------------------------------------------
+**
+**
+*/
+
+#include "gl_interleaved3d.h"
+#include "gl/renderer/gl_renderer.h"
+#include "gl/renderer/gl_renderbuffers.h"
+#include "gl/renderer/gl_renderer.h"
+#include "gl/system/gl_framebuffer.h"
+#include "gl/shaders/gl_present3dRowshader.h"
+
+EXTERN_CVAR(Float, vid_brightness)
+EXTERN_CVAR(Float, vid_contrast)
+EXTERN_CVAR(Bool, fullscreen)
+EXTERN_CVAR(Int, win_y) // pixel position of top of display window
+
+namespace s3d {
+
+/* static */
+const RowInterleaved3D& RowInterleaved3D::getInstance(float ipd)
+{
+	static RowInterleaved3D instance(ipd);
+	return instance;
+}
+
+RowInterleaved3D::RowInterleaved3D(double ipdMeters) 
+	: TopBottom3D(ipdMeters)
+{}
+
+void RowInterleaved3D::Present() const
+{
+	GLRenderer->mBuffers->BindOutputFB();
+	GLRenderer->ClearBorders();
+
+
+	// Bind each eye texture, for composition in the shader
+	GLRenderer->mBuffers->BindEyeTexture(0, 0);
+	GLRenderer->mBuffers->BindEyeTexture(1, 1);
+
+	glActiveTexture(GL_TEXTURE0);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+	glActiveTexture(GL_TEXTURE1);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+	const GL_IRECT& box = GLRenderer->mOutputLetterbox;
+	glViewport(box.left, box.top, box.width, box.height);
+
+	bool applyGamma = true;
+
+	GLRenderer->mPresent3dRowShader->Bind();
+	GLRenderer->mPresent3dRowShader->LeftEyeTexture.Set(0);
+	GLRenderer->mPresent3dRowShader->RightEyeTexture.Set(1);
+
+	if (!applyGamma || GLRenderer->framebuffer->IsHWGammaActive())
+	{
+		GLRenderer->mPresent3dRowShader->InvGamma.Set(1.0f);
+		GLRenderer->mPresent3dRowShader->Contrast.Set(1.0f);
+		GLRenderer->mPresent3dRowShader->Brightness.Set(0.0f);
+	}
+	else
+	{
+		GLRenderer->mPresent3dRowShader->InvGamma.Set(1.0f / clamp<float>(Gamma, 0.1f, 4.f));
+		GLRenderer->mPresent3dRowShader->Contrast.Set(clamp<float>(vid_contrast, 0.1f, 3.f));
+		GLRenderer->mPresent3dRowShader->Brightness.Set(clamp<float>(vid_brightness, -0.8f, 0.8f));
+	}
+	GLRenderer->mPresent3dRowShader->Scale.Set(
+		GLRenderer->mScreenViewport.width / (float)GLRenderer->mBuffers->GetWidth(),
+		GLRenderer->mScreenViewport.height / (float)GLRenderer->mBuffers->GetHeight());
+
+	// Compute absolute offset from top of screen to top of current display window
+	// because we need screen-relative, not window-relative, scan line parity
+	int windowVOffset = 0;
+	if (! fullscreen) {
+		I_SaveWindowedPos(); // update win_y CVAR
+		windowVOffset = win_y;
+	}
+
+	GLRenderer->mPresent3dRowShader->VerticalPixelOffset.Set(
+		windowVOffset // fixme: vary with window location
+		+ box.height % 2 // because we want the top pixel offset, but gl_FragCoord.y is the bottom pixel offset
+	);
+
+	GLRenderer->RenderScreenQuad();
+}
+
+
+} /* namespace s3d */

src/gl/stereo3d/gl_interleaved3d.h

@@ -0,0 +1,60 @@
+/*
+** gl_interleaved3d.h
+** Interleaved stereoscopic 3D modes for GZDoom
+**
+**---------------------------------------------------------------------------
+** Copyright 2016 Christopher Bruns
+** All rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+**
+** 1. Redistributions of source code must retain the above copyright
+**    notice, this list of conditions and the following disclaimer.
+** 2. 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.
+** 3. The name of the author may not be used to endorse or promote products
+**    derived from this software without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+**---------------------------------------------------------------------------
+**
+**
+*/
+
+#ifndef GL_INTERLEAVED3D_H_
+#define GL_INTERLEAVED3D_H_
+
+#include "gl_stereo3d.h"
+#include "gl_stereo_leftright.h"
+#include "gl_sidebyside3d.h"
+#include "gl/system/gl_system.h"
+#include "gl/renderer/gl_renderstate.h"
+
+class FPresent3DRowShader;
+
+namespace s3d {
+
+class RowInterleaved3D : public TopBottom3D
+{
+public:
+	static const RowInterleaved3D& getInstance(float ipd);
+	RowInterleaved3D(double ipdMeters);
+	void Present() const override;
+};
+
+} /* namespace s3d */
+
+
+#endif /* GL_INTERLEAVED3D_H_ */

src/gl/stereo3d/gl_sidebyside3d.cpp

@@ -108,4 +108,43 @@ void SideBySideFull::AdjustPlayerSprites() const /* override */
 	gl_RenderState.ApplyMatrices();
 }
 
+/* static */
+const TopBottom3D& TopBottom3D::getInstance(float ipd)
+{
+	static TopBottom3D instance(ipd);
+	return instance;
+}
+
+void TopBottom3D::Present() const
+{
+	GLRenderer->mBuffers->BindOutputFB();
+	GLRenderer->ClearBorders();
+
+	// Compute screen regions to use for left and right eye views
+	int topHeight = GLRenderer->mOutputLetterbox.height / 2;
+	int bottomHeight = GLRenderer->mOutputLetterbox.height - topHeight;
+	GL_IRECT topHalfScreen = GLRenderer->mOutputLetterbox;
+	topHalfScreen.height = topHeight;
+	topHalfScreen.top = topHeight;
+	GL_IRECT bottomHalfScreen = GLRenderer->mOutputLetterbox;
+	bottomHalfScreen.height = bottomHeight;
+	bottomHalfScreen.top = 0;
+
+	GLRenderer->mBuffers->BindEyeTexture(0, 0);
+	GLRenderer->DrawPresentTexture(topHalfScreen, true);
+
+	GLRenderer->mBuffers->BindEyeTexture(1, 0);
+	GLRenderer->DrawPresentTexture(bottomHalfScreen, true);
+}
+
+// AdjustViewports() is called from within FLGRenderer::SetOutputViewport(...)
+void TopBottom3D::AdjustViewports() const
+{
+	// Change size of renderbuffer, and align to screen
+	GLRenderer->mSceneViewport.height /= 2;
+	GLRenderer->mSceneViewport.top /= 2;
+	GLRenderer->mScreenViewport.height /= 2;
+	GLRenderer->mScreenViewport.top /= 2;
+}
+
 } /* namespace s3d */

src/gl/stereo3d/gl_sidebyside3d.h

@@ -88,6 +88,14 @@ private:
 	SBSFRightEyePose rightEye;
 };
 
+class TopBottom3D : public SideBySideSquished
+{
+public:
+	static const TopBottom3D& getInstance(float ipd);
+	TopBottom3D(double ipdMeters) : SideBySideSquished(ipdMeters) {}
+	void Present() const override;
+	virtual void AdjustViewports() const override;
+};
 
 } /* namespace s3d */
 

src/gl/stereo3d/gl_stereo_cvars.cpp

@@ -30,6 +30,7 @@
 #include "gl/stereo3d/gl_anaglyph.h"
 #include "gl/stereo3d/gl_quadstereo.h"
 #include "gl/stereo3d/gl_sidebyside3d.h"
+#include "gl/stereo3d/gl_interleaved3d.h"
 #include "gl/system/gl_cvars.h"
 
 // Set up 3D-specific console variables:
@@ -100,6 +101,12 @@ const Stereo3DMode& Stereo3DMode::getCurrentMode()
 		setCurrentMode(AmberBlue::getInstance(vr_ipd));
 		break;	
 	// TODO: 10: HTC Vive/OpenVR
+	case 11:
+		setCurrentMode(TopBottom3D::getInstance(vr_ipd));
+		break;
+	case 12:
+		setCurrentMode(RowInterleaved3D::getInstance(vr_ipd));
+		break;
 	case 0:
 	default:
 		setCurrentMode(MonoView::getInstance());

wadsrc/static/language.enu

@@ -2638,6 +2638,7 @@ GLPREFMNU_MULTISAMPLE			= "Multisample";
 GLPREFMNU_TONEMAP				= "Tonemap Mode";
 GLPREFMNU_BLOOM					= "Bloom effect";
 GLPREFMNU_LENS					= "Lens distortion effect";
+GLPREFMNU_FXAA					= "FXAA Quality";
 GLPREFMNU_SSAO					= "Ambient occlusion";
 
 // Option Values
@@ -2709,6 +2710,8 @@ OPTVAL_LEFTEYE 				= "Left Eye";
 OPTVAL_RIGHTEYE 			= "Right Eye";
 OPTVAL_SBSFULL		    	= "Side-by-side Full";
 OPTVAL_SBSNARROW			= "Side-by-side Narrow";
+OPTVAL_TOPBOTTOM			= "Top/Bottom";
+OPTVAL_ROWINTERLEAVED		= "Row Interleaved";
 OPTVAL_QUADBUFFERED 		= "Quad-buffered";
 OPTVAL_UNCHARTED2			= "Uncharted 2";
 OPTVAL_HEJLDAWSON			= "Hejl Dawson";
@@ -2717,3 +2720,4 @@ OPTVAL_PALETTE				= "Palette";
 OPTVAL_LOW					= "Low";
 OPTVAL_MEDIUM				= "Medium";
 OPTVAL_HIGH					= "High";
+OPTVAL_EXTREME				= "Extreme";

wadsrc/static/menudef.zz

@@ -49,6 +49,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"
@@ -176,6 +185,8 @@ OptionValue VRMode
 	9, "$OPTVAL_AMBERBLUE"
 	3, "$OPTVAL_SBSFULL"
 	4, "$OPTVAL_SBSNARROW"
+	11, "$OPTVAL_TOPBOTTOM"
+	12, "$OPTVAL_ROWINTERLEAVED"
 	5, "$OPTVAL_LEFTEYE"
 	6, "$OPTVAL_RIGHTEYE"
 	7, "$OPTVAL_QUADBUFFERED"
@@ -234,5 +245,6 @@ 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"
 	Option "$GLPREFMNU_SSAO",		 			gl_ssao,						"OnOff"
 }

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

wadsrc/static/shaders/glsl/present_row3d.fp

@@ -0,0 +1,35 @@
+
+in vec2 TexCoord;
+out vec4 FragColor;
+
+uniform sampler2D LeftEyeTexture;
+uniform sampler2D RightEyeTexture;
+uniform float InvGamma;
+uniform float Contrast;
+uniform float Brightness;
+uniform int VerticalPixelOffset; // top-of-window might not be top-of-screen
+
+vec4 ApplyGamma(vec4 c)
+{
+	vec3 val = c.rgb * Contrast - (Contrast - 1.0) * 0.5;
+	val += Brightness * 0.5;
+	val = pow(max(val, vec3(0.0)), vec3(InvGamma));
+	return vec4(val, c.a);
+}
+
+void main()
+{
+	int thisVerticalPixel = int(gl_FragCoord.y + 1.0); // Bottom row is typically the right eye, when WindowHeight is even
+	bool isLeftEye = (thisVerticalPixel // because we want to alternate eye view on each row
+		 + VerticalPixelOffset // because the window might not be aligned to the screen
+		) % 2 == 0;
+	vec4 inputColor;
+	if (isLeftEye) {
+		inputColor = texture(LeftEyeTexture, TexCoord);
+	}
+	else {
+		// inputColor = vec4(0, 1, 0, 1);
+		inputColor = texture(RightEyeTexture, TexCoord);
+	}
+	FragColor = ApplyGamma(inputColor);
+}