From 34692ab826abc8f8faa61bdb2280b742424528f1 Mon Sep 17 00:00:00 2001
From: "Jasper St. Pierre" <jstpierre@mecheye.net>
Date: Sat, 7 Dec 2013 15:14:29 -0500
Subject: Remove unnecessary Src/ folders

---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 154 +++++++++++++++++++++++
 1 file changed, 154 insertions(+)
 create mode 100644 Source/Core/VideoBackends/OGL/PostProcessing.cpp

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
new file mode 100644
index 0000000000..c0460e489a
--- /dev/null
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -0,0 +1,154 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include "CommonPaths.h"
+#include "FileUtil.h"
+#include "VideoCommon.h"
+#include "VideoConfig.h"
+#include "GLUtil.h"
+#include "PostProcessing.h"
+#include "ProgramShaderCache.h"
+#include "FramebufferManager.h"
+
+namespace OGL
+{
+
+namespace PostProcessing
+{
+
+static std::string s_currentShader;
+static SHADER s_shader;
+static bool s_enable;
+
+static u32 s_width;
+static u32 s_height;
+static GLuint s_fbo;
+static GLuint s_texture;
+
+static GLuint s_uniform_resolution;
+
+static char s_vertex_shader[] =
+	"out vec2 uv0;\n"
+	"void main(void) {\n"
+	"	vec2 rawpos = vec2(gl_VertexID&1, gl_VertexID&2);\n"
+	"	gl_Position = vec4(rawpos*2.0-1.0, 0.0, 1.0);\n"
+	"	uv0 = rawpos;\n"
+	"}\n";
+
+void Init()
+{
+	s_currentShader = "";
+	s_enable = 0;
+	s_width = 0;
+	s_height = 0;
+
+	glGenFramebuffers(1, &s_fbo);
+	glGenTextures(1, &s_texture);
+	glBindTexture(GL_TEXTURE_2D, s_texture);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); // disable mipmaps
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+	glBindFramebuffer(GL_FRAMEBUFFER, s_fbo);
+	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, s_texture, 0);
+	FramebufferManager::SetFramebuffer(0);
+}
+
+void Shutdown()
+{
+	s_shader.Destroy();
+
+	glDeleteFramebuffers(1, &s_fbo);
+	glDeleteTextures(1, &s_texture);
+}
+
+void ReloadShader()
+{
+	s_currentShader = "";
+}
+
+void BindTargetFramebuffer ()
+{
+	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, s_enable ? s_fbo : 0);
+}
+
+void BlitToScreen()
+{
+	if(!s_enable) return;
+
+	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
+	glViewport(0, 0, s_width, s_height);
+
+	s_shader.Bind();
+
+	glUniform4f(s_uniform_resolution, (float)s_width, (float)s_height, 1.0f/(float)s_width, 1.0f/(float)s_height);
+
+	glActiveTexture(GL_TEXTURE0+9);
+	glBindTexture(GL_TEXTURE_2D, s_texture);
+	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+/*	glBindFramebuffer(GL_READ_FRAMEBUFFER, s_fbo);
+
+	glBlitFramebuffer(rc.left, rc.bottom, rc.right, rc.top,
+			rc.left, rc.bottom, rc.right, rc.top,
+			GL_COLOR_BUFFER_BIT, GL_NEAREST);*/
+}
+
+void Update ( u32 width, u32 height )
+{
+	ApplyShader();
+
+	if(s_enable && (width != s_width || height != s_height)) {
+		s_width = width;
+		s_height = height;
+
+		// alloc texture for framebuffer
+		glActiveTexture(GL_TEXTURE0+9);
+		glBindTexture(GL_TEXTURE_2D, s_texture);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+	}
+}
+
+void ApplyShader()
+{
+	// shader didn't changed
+	if (s_currentShader == g_ActiveConfig.sPostProcessingShader) return;
+	s_currentShader = g_ActiveConfig.sPostProcessingShader;
+	s_enable = false;
+	s_shader.Destroy();
+
+	// shader disabled
+	if (g_ActiveConfig.sPostProcessingShader == "") return;
+
+	// so need to compile shader
+
+	// loading shader code
+	std::string code;
+	std::string path = File::GetUserPath(D_SHADERS_IDX) + g_ActiveConfig.sPostProcessingShader + ".glsl";
+	if (!File::Exists(path))
+	{
+		// Fallback to shared user dir
+		path = File::GetSysDirectory() + SHADERS_DIR DIR_SEP + g_ActiveConfig.sPostProcessingShader + ".glsl";
+	}
+	if(!File::ReadFileToString(path.c_str(), code)) {
+		ERROR_LOG(VIDEO, "Post-processing shader not found: %s", path.c_str());
+		return;
+	}
+
+	// and compile it
+	if (!ProgramShaderCache::CompileShader(s_shader, s_vertex_shader, code.c_str())) {
+		ERROR_LOG(VIDEO, "Failed to compile post-processing shader %s", s_currentShader.c_str());
+		return;
+	}
+
+	// read uniform locations
+	s_uniform_resolution = glGetUniformLocation(s_shader.glprogid, "resolution");
+
+	// successful
+	s_enable = true;
+}
+
+}  // namespace
+
+}  // namespace OGL
-- 
cgit v1.2.3


From 2afe2152712981e21d6bda6f029292ed2b1cf91e Mon Sep 17 00:00:00 2001
From: Lioncash <mathew1800@gmail.com>
Date: Mon, 17 Feb 2014 05:18:15 -0500
Subject: Convert all includes to relative paths.

---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index c0460e489a..211cf5d937 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -2,14 +2,16 @@
 // Licensed under GPLv2
 // Refer to the license.txt file included.
 
-#include "CommonPaths.h"
-#include "FileUtil.h"
-#include "VideoCommon.h"
-#include "VideoConfig.h"
-#include "GLUtil.h"
-#include "PostProcessing.h"
-#include "ProgramShaderCache.h"
-#include "FramebufferManager.h"
+#include "Common/CommonPaths.h"
+#include "Common/FileUtil.h"
+
+#include "VideoBackends/OGL/FramebufferManager.h"
+#include "VideoBackends/OGL/GLUtil.h"
+#include "VideoBackends/OGL/PostProcessing.h"
+#include "VideoBackends/OGL/ProgramShaderCache.h"
+
+#include "VideoCommon/VideoCommon.h"
+#include "VideoCommon/VideoConfig.h"
 
 namespace OGL
 {
-- 
cgit v1.2.3


From d802d392811be44d34ae9cd23f616db93e54c50f Mon Sep 17 00:00:00 2001
From: Tillmann Karras <tilkax@gmail.com>
Date: Sun, 9 Mar 2014 21:14:26 +0100
Subject: clang-modernize -use-nullptr

and s/\bNULL\b/nullptr/g for *.cpp/h/mm files not compiled on my machine
---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 211cf5d937..929fcd0de8 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -51,7 +51,7 @@ void Init()
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); // disable mipmaps
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 	glBindFramebuffer(GL_FRAMEBUFFER, s_fbo);
 	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, s_texture, 0);
 	FramebufferManager::SetFramebuffer(0);
@@ -108,7 +108,7 @@ void Update ( u32 width, u32 height )
 		// alloc texture for framebuffer
 		glActiveTexture(GL_TEXTURE0+9);
 		glBindTexture(GL_TEXTURE_2D, s_texture);
-		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 	}
 }
 
-- 
cgit v1.2.3


From 31cfc73a09a8685cbab20502b4bc132e98e2feb5 Mon Sep 17 00:00:00 2001
From: Matthew Parlane <parlane@gmail.com>
Date: Tue, 11 Mar 2014 00:30:55 +1300
Subject: Fixes spacing for "for", "while", "switch" and "if" Also moved && and
 || to ends of lines instead of start. Fixed misc vertical alignments and some
 { needed newlining.

---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 929fcd0de8..a4a4c0bbf3 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -77,7 +77,7 @@ void BindTargetFramebuffer ()
 
 void BlitToScreen()
 {
-	if(!s_enable) return;
+	if (!s_enable) return;
 
 	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
 	glViewport(0, 0, s_width, s_height);
@@ -101,7 +101,7 @@ void Update ( u32 width, u32 height )
 {
 	ApplyShader();
 
-	if(s_enable && (width != s_width || height != s_height)) {
+	if (s_enable && (width != s_width || height != s_height)) {
 		s_width = width;
 		s_height = height;
 
@@ -133,7 +133,7 @@ void ApplyShader()
 		// Fallback to shared user dir
 		path = File::GetSysDirectory() + SHADERS_DIR DIR_SEP + g_ActiveConfig.sPostProcessingShader + ".glsl";
 	}
-	if(!File::ReadFileToString(path.c_str(), code)) {
+	if (!File::ReadFileToString(path.c_str(), code)) {
 		ERROR_LOG(VIDEO, "Post-processing shader not found: %s", path.c_str());
 		return;
 	}
-- 
cgit v1.2.3


From a82675b7d581421fa80d5d5c53253cf1d5c1a26d Mon Sep 17 00:00:00 2001
From: Lioncash <mathew1800@gmail.com>
Date: Wed, 12 Mar 2014 15:33:41 -0400
Subject: Kill off some usages of c_str.

Also changes some function params, but this is ok.
Some simplifications were also able to be made (ie. killing off strcmps with ==, etc).
---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index a4a4c0bbf3..e885d63a56 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -133,7 +133,7 @@ void ApplyShader()
 		// Fallback to shared user dir
 		path = File::GetSysDirectory() + SHADERS_DIR DIR_SEP + g_ActiveConfig.sPostProcessingShader + ".glsl";
 	}
-	if (!File::ReadFileToString(path.c_str(), code)) {
+	if (!File::ReadFileToString(path, code)) {
 		ERROR_LOG(VIDEO, "Post-processing shader not found: %s", path.c_str());
 		return;
 	}
-- 
cgit v1.2.3


From 6bdc32c54aa19b8b61b19a4b11167ba329667b0a Mon Sep 17 00:00:00 2001
From: Ryan Houdek <Sonicadvance1@gmail.com>
Date: Tue, 29 Jul 2014 11:47:56 -0500
Subject: Add the VideoCommon PostProcessing class.

This class loads all the common PP shader configuration options and passes those options through to a inherited class that OpenGL or D3D will have.
Makes it so all the common code for PP shaders is in VideoCommon instead of duplicating the code across each backend.
---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 94 +++++++++++++++++++++---
 1 file changed, 84 insertions(+), 10 deletions(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index e885d63a56..06a15b07cc 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -40,14 +40,13 @@ static char s_vertex_shader[] =
 
 void Init()
 {
-	s_currentShader = "";
-	s_enable = 0;
-	s_width = 0;
-	s_height = 0;
+	m_enable = false;
+	m_width = 0;
+	m_height = 0;
 
-	glGenFramebuffers(1, &s_fbo);
-	glGenTextures(1, &s_texture);
-	glBindTexture(GL_TEXTURE_2D, s_texture);
+	glGenFramebuffers(1, &m_fbo);
+	glGenTextures(1, &m_texture);
+	glBindTexture(GL_TEXTURE_2D, m_texture);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); // disable mipmaps
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
@@ -59,7 +58,7 @@ void Init()
 
 void Shutdown()
 {
-	s_shader.Destroy();
+	m_shader.Destroy();
 
 	glDeleteFramebuffers(1, &s_fbo);
 	glDeleteTextures(1, &s_texture);
@@ -84,6 +83,9 @@ void BlitToScreen()
 
 	s_shader.Bind();
 
+	glUniform4f(m_uniform_resolution, (float)m_width, (float)m_height, 1.0f/(float)m_width, 1.0f/(float)m_height);
+	glUniform1ui(m_uniform_time, (GLuint)m_timer.GetTimeElapsed());
+
 	glUniform4f(s_uniform_resolution, (float)s_width, (float)s_height, 1.0f/(float)s_width, 1.0f/(float)s_height);
 
 	glActiveTexture(GL_TEXTURE0+9);
@@ -145,10 +147,82 @@ void ApplyShader()
 	}
 
 	// read uniform locations
-	s_uniform_resolution = glGetUniformLocation(s_shader.glprogid, "resolution");
+	m_uniform_resolution = glGetUniformLocation(m_shader.glprogid, "resolution");
+	m_uniform_time = glGetUniformLocation(m_shader.glprogid, "time");
+
+	for (const auto& it : m_options)
+	{
+		std::string glsl_name = "option_" + it.first;
+		m_uniform_bindings[it.first] = glGetUniformLocation(m_shader.glprogid, glsl_name.c_str());
+	}
 
 	// successful
-	s_enable = true;
+	m_enable = true;
+}
+
+void OpenGLPostProcessing::CreateHeader()
+{
+	m_glsl_header =
+		// Required variables
+		// Shouldn't be accessed directly by the PP shader
+		// Texture sampler
+		"SAMPLER_BINDING(8) uniform sampler2D samp8;\n"
+		"SAMPLER_BINDING(9) uniform sampler2D samp9;\n"
+
+		// Output variable
+		"out float4 ocol0;\n"
+		// Input coordinates
+		"in float2 uv0;\n"
+		// Resolution
+		"uniform float4 resolution;\n"
+		// Time
+		"uniform uint time;\n"
+
+		// Interfacing functions
+		"float4 Sample()\n"
+		"{\n"
+			"\treturn texture(samp9, uv0);\n"
+		"}\n"
+
+		"float4 SampleLocation(float2 location)\n"
+		"{\n"
+			"\treturn texture(samp9, location);\n"
+		"}\n"
+
+		"#define SampleOffset(offset) textureOffset(samp9, uv0, offset)\n"
+
+		"float4 SampleFontLocation(float2 location)\n"
+		"{\n"
+			"\treturn texture(samp8, location);\n"
+		"}\n"
+
+		"float2 GetResolution()\n"
+		"{\n"
+			"\treturn resolution.xy;\n"
+		"}\n"
+
+		"float2 GetInvResolution()\n"
+		"{\n"
+			"\treturn resolution.zw;\n"
+		"}\n"
+
+		"float2 GetCoordinates()\n"
+		"{\n"
+			"\treturn uv0;\n"
+		"}\n"
+
+		"uint GetTime()\n"
+		"{\n"
+			"\treturn time;\n"
+		"}\n"
+
+		"void SetOutput(float4 color)\n"
+		"{\n"
+			"\tocol0 = color;\n"
+		"}\n"
+
+		"#define GetOption(x) (option_#x)\n"
+		"#define OptionEnabled(x) (option_#x != 0)\n";
 }
 
 }  // namespace
-- 
cgit v1.2.3


From cced3b4a18b5116a715bb2bfc40f3f6c47165640 Mon Sep 17 00:00:00 2001
From: Ryan Houdek <Sonicadvance1@gmail.com>
Date: Tue, 29 Jul 2014 11:57:02 -0500
Subject: Change OpenGL's post processing to use the new VideoCommon PP object.

Let's OpenGL's PostProcessing namespace be changed to a class inheriting from VideoCommon's PostProcessing class.
---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 202 +++++++++++++++--------
 1 file changed, 137 insertions(+), 65 deletions(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 06a15b07cc..dee133ed03 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -4,6 +4,7 @@
 
 #include "Common/CommonPaths.h"
 #include "Common/FileUtil.h"
+#include "Common/StringUtil.h"
 
 #include "VideoBackends/OGL/FramebufferManager.h"
 #include "VideoBackends/OGL/GLUtil.h"
@@ -16,20 +17,6 @@
 namespace OGL
 {
 
-namespace PostProcessing
-{
-
-static std::string s_currentShader;
-static SHADER s_shader;
-static bool s_enable;
-
-static u32 s_width;
-static u32 s_height;
-static GLuint s_fbo;
-static GLuint s_texture;
-
-static GLuint s_uniform_resolution;
-
 static char s_vertex_shader[] =
 	"out vec2 uv0;\n"
 	"void main(void) {\n"
@@ -38,7 +25,7 @@ static char s_vertex_shader[] =
 	"	uv0 = rawpos;\n"
 	"}\n";
 
-void Init()
+OpenGLPostProcessing::OpenGLPostProcessing()
 {
 	m_enable = false;
 	m_width = 0;
@@ -51,98 +38,151 @@ void Init()
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
-	glBindFramebuffer(GL_FRAMEBUFFER, s_fbo);
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, s_texture, 0);
+	glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
+	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texture, 0);
 	FramebufferManager::SetFramebuffer(0);
+
+	CreateHeader();
 }
 
-void Shutdown()
+OpenGLPostProcessing::~OpenGLPostProcessing()
 {
 	m_shader.Destroy();
 
-	glDeleteFramebuffers(1, &s_fbo);
-	glDeleteTextures(1, &s_texture);
+	glDeleteFramebuffers(1, &m_fbo);
+	glDeleteTextures(1, &m_texture);
 }
 
-void ReloadShader()
+void OpenGLPostProcessing::BindTargetFramebuffer()
 {
-	s_currentShader = "";
+	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_enable ? m_fbo : 0);
 }
 
-void BindTargetFramebuffer ()
+void OpenGLPostProcessing::BlitToScreen()
 {
-	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, s_enable ? s_fbo : 0);
-}
-
-void BlitToScreen()
-{
-	if (!s_enable) return;
+	if (!m_enable) return;
 
 	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
-	glViewport(0, 0, s_width, s_height);
+	glViewport(0, 0, m_width, m_height);
 
-	s_shader.Bind();
+	m_shader.Bind();
 
 	glUniform4f(m_uniform_resolution, (float)m_width, (float)m_height, 1.0f/(float)m_width, 1.0f/(float)m_height);
 	glUniform1ui(m_uniform_time, (GLuint)m_timer.GetTimeElapsed());
 
-	glUniform4f(s_uniform_resolution, (float)s_width, (float)s_height, 1.0f/(float)s_width, 1.0f/(float)s_height);
+	if (m_config.IsDirty())
+	{
+		for (auto& it : m_config.GetOptions())
+		{
+			if (it.second.m_dirty)
+			{
+				switch (it.second.m_type)
+				{
+				case PostProcessingShaderConfiguration::ConfigurationOption::OptionType::OPTION_BOOL:
+					glUniform1i(m_uniform_bindings[it.first], it.second.m_bool_value);
+				break;
+				case PostProcessingShaderConfiguration::ConfigurationOption::OptionType::OPTION_INTEGER:
+					switch (it.second.m_integer_values.size())
+					{
+					case 1:
+						glUniform1i(m_uniform_bindings[it.first], it.second.m_integer_values[0]);
+					break;
+					case 2:
+						glUniform2i(m_uniform_bindings[it.first],
+								it.second.m_integer_values[0],
+						            it.second.m_integer_values[1]);
+					break;
+					case 3:
+						glUniform3i(m_uniform_bindings[it.first],
+								it.second.m_integer_values[0],
+								it.second.m_integer_values[1],
+						            it.second.m_integer_values[2]);
+					break;
+					case 4:
+						glUniform4i(m_uniform_bindings[it.first],
+								it.second.m_integer_values[0],
+								it.second.m_integer_values[1],
+								it.second.m_integer_values[2],
+						            it.second.m_integer_values[3]);
+					break;
+					}
+				break;
+				case PostProcessingShaderConfiguration::ConfigurationOption::OptionType::OPTION_FLOAT:
+					switch (it.second.m_float_values.size())
+					{
+					case 1:
+						glUniform1f(m_uniform_bindings[it.first], it.second.m_float_values[0]);
+					break;
+					case 2:
+						glUniform2f(m_uniform_bindings[it.first],
+								it.second.m_float_values[0],
+						            it.second.m_float_values[1]);
+					break;
+					case 3:
+						glUniform3f(m_uniform_bindings[it.first],
+								it.second.m_float_values[0],
+								it.second.m_float_values[1],
+						            it.second.m_float_values[2]);
+					break;
+					case 4:
+						glUniform4f(m_uniform_bindings[it.first],
+								it.second.m_float_values[0],
+								it.second.m_float_values[1],
+								it.second.m_float_values[2],
+						            it.second.m_float_values[3]);
+					break;
+					}
+				break;
+				}
+				it.second.m_dirty = false;
+			}
+		}
+		m_config.SetDirty(false);
+	}
 
 	glActiveTexture(GL_TEXTURE0+9);
-	glBindTexture(GL_TEXTURE_2D, s_texture);
+	glBindTexture(GL_TEXTURE_2D, m_texture);
 	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-
-/*	glBindFramebuffer(GL_READ_FRAMEBUFFER, s_fbo);
-
-	glBlitFramebuffer(rc.left, rc.bottom, rc.right, rc.top,
-			rc.left, rc.bottom, rc.right, rc.top,
-			GL_COLOR_BUFFER_BIT, GL_NEAREST);*/
 }
 
-void Update ( u32 width, u32 height )
+void OpenGLPostProcessing::Update(u32 width, u32 height)
 {
 	ApplyShader();
 
-	if (s_enable && (width != s_width || height != s_height)) {
-		s_width = width;
-		s_height = height;
+	if (m_enable && (width != m_width || height != m_height))
+	{
+		m_width = width;
+		m_height = height;
 
 		// alloc texture for framebuffer
 		glActiveTexture(GL_TEXTURE0+9);
-		glBindTexture(GL_TEXTURE_2D, s_texture);
+		glBindTexture(GL_TEXTURE_2D, m_texture);
 		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 	}
 }
 
-void ApplyShader()
+void OpenGLPostProcessing::ApplyShader()
 {
 	// shader didn't changed
-	if (s_currentShader == g_ActiveConfig.sPostProcessingShader) return;
-	s_currentShader = g_ActiveConfig.sPostProcessingShader;
-	s_enable = false;
-	s_shader.Destroy();
+	if (m_config.GetShader() == g_ActiveConfig.sPostProcessingShader) return;
+
+	m_enable = false;
+	m_shader.Destroy();
+	m_uniform_bindings.clear();
 
 	// shader disabled
 	if (g_ActiveConfig.sPostProcessingShader == "") return;
 
 	// so need to compile shader
+	std::string code = m_config.LoadShader();
 
-	// loading shader code
-	std::string code;
-	std::string path = File::GetUserPath(D_SHADERS_IDX) + g_ActiveConfig.sPostProcessingShader + ".glsl";
-	if (!File::Exists(path))
-	{
-		// Fallback to shared user dir
-		path = File::GetSysDirectory() + SHADERS_DIR DIR_SEP + g_ActiveConfig.sPostProcessingShader + ".glsl";
-	}
-	if (!File::ReadFileToString(path, code)) {
-		ERROR_LOG(VIDEO, "Post-processing shader not found: %s", path.c_str());
-		return;
-	}
+	if (code == "") return;
+
+	code = LoadShaderOptions(code);
 
 	// and compile it
-	if (!ProgramShaderCache::CompileShader(s_shader, s_vertex_shader, code.c_str())) {
-		ERROR_LOG(VIDEO, "Failed to compile post-processing shader %s", s_currentShader.c_str());
+	if (!ProgramShaderCache::CompileShader(m_shader, s_vertex_shader, code.c_str())) {
+		ERROR_LOG(VIDEO, "Failed to compile post-processing shader %s", m_config.GetShader().c_str());
 		return;
 	}
 
@@ -150,7 +190,7 @@ void ApplyShader()
 	m_uniform_resolution = glGetUniformLocation(m_shader.glprogid, "resolution");
 	m_uniform_time = glGetUniformLocation(m_shader.glprogid, "time");
 
-	for (const auto& it : m_options)
+	for (const auto& it : m_config.GetOptions())
 	{
 		std::string glsl_name = "option_" + it.first;
 		m_uniform_bindings[it.first] = glGetUniformLocation(m_shader.glprogid, glsl_name.c_str());
@@ -225,6 +265,38 @@ void OpenGLPostProcessing::CreateHeader()
 		"#define OptionEnabled(x) (option_#x != 0)\n";
 }
 
-}  // namespace
+std::string OpenGLPostProcessing::LoadShaderOptions(const std::string& code)
+{
+	std::string glsl_options = "";
+	m_uniform_bindings.clear();
+
+	for (const auto& it : m_config.GetOptions())
+	{
+		if (it.second.m_type == PostProcessingShaderConfiguration::ConfigurationOption::OptionType::OPTION_BOOL)
+		{
+			glsl_options += StringFromFormat("uniform int     option_%s;\n", it.first.c_str());
+		}
+		else if (it.second.m_type == PostProcessingShaderConfiguration::ConfigurationOption::OptionType::OPTION_INTEGER)
+		{
+			u32 count = it.second.m_integer_values.size();
+			if (count == 1)
+				glsl_options += StringFromFormat("uniform int     option_%s;\n", it.first.c_str());
+			else
+				glsl_options += StringFromFormat("uniform int%d   option_%s;\n", count, it.first.c_str());
+		}
+		else if (it.second.m_type == PostProcessingShaderConfiguration::ConfigurationOption::OptionType::OPTION_FLOAT)
+		{
+			u32 count = it.second.m_float_values.size();
+			if (count == 1)
+				glsl_options += StringFromFormat("uniform float   option_%s;\n", it.first.c_str());
+			else
+				glsl_options += StringFromFormat("uniform float%d option_%s;\n", count, it.first.c_str());
+		}
+
+		m_uniform_bindings[it.first] = 0;
+	}
+
+	return m_glsl_header + glsl_options + code;
+}
 
 }  // namespace OGL
-- 
cgit v1.2.3


From 960b54670ca3c2625eaaaee725e093b3f03251c5 Mon Sep 17 00:00:00 2001
From: Lioncash <mathew1800@gmail.com>
Date: Fri, 15 Aug 2014 14:09:53 -0400
Subject: OGL: Fix brace and body placements

Also got rid of void argument specifiers. These are a carryover from C.
---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index dee133ed03..15c89a9443 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -164,24 +164,28 @@ void OpenGLPostProcessing::Update(u32 width, u32 height)
 void OpenGLPostProcessing::ApplyShader()
 {
 	// shader didn't changed
-	if (m_config.GetShader() == g_ActiveConfig.sPostProcessingShader) return;
+	if (m_config.GetShader() == g_ActiveConfig.sPostProcessingShader)
+		return;
 
 	m_enable = false;
 	m_shader.Destroy();
 	m_uniform_bindings.clear();
 
 	// shader disabled
-	if (g_ActiveConfig.sPostProcessingShader == "") return;
+	if (g_ActiveConfig.sPostProcessingShader == "")
+		return;
 
 	// so need to compile shader
 	std::string code = m_config.LoadShader();
 
-	if (code == "") return;
+	if (code == "")
+		return;
 
 	code = LoadShaderOptions(code);
 
 	// and compile it
-	if (!ProgramShaderCache::CompileShader(m_shader, s_vertex_shader, code.c_str())) {
+	if (!ProgramShaderCache::CompileShader(m_shader, s_vertex_shader, code.c_str()))
+	{
 		ERROR_LOG(VIDEO, "Failed to compile post-processing shader %s", m_config.GetShader().c_str());
 		return;
 	}
-- 
cgit v1.2.3


From 32fb61816b95707d8adac423d997db72367da4ce Mon Sep 17 00:00:00 2001
From: Ryan Houdek <Sonicadvance1@gmail.com>
Date: Sun, 17 Aug 2014 21:22:00 -0500
Subject: Fixes PP-shaders on !Mesa targets.

Seems mesa has a quirk where
define THING(x) (#x)
is the same as
define THING(x) (##x)

Didn't realize I messed it up since it just worked since I only tested on Mesa.
---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 15c89a9443..10ccf9fba8 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -265,8 +265,8 @@ void OpenGLPostProcessing::CreateHeader()
 			"\tocol0 = color;\n"
 		"}\n"
 
-		"#define GetOption(x) (option_#x)\n"
-		"#define OptionEnabled(x) (option_#x != 0)\n";
+		"#define GetOption(x) (option_##x)\n"
+		"#define OptionEnabled(x) (option_##x != 0)\n";
 }
 
 std::string OpenGLPostProcessing::LoadShaderOptions(const std::string& code)
-- 
cgit v1.2.3


From 5471c71819b40595a23d81a2e5fa605a4d5c2c0d Mon Sep 17 00:00:00 2001
From: Shawn Hoffman <godisgovernment@gmail.com>
Date: Tue, 19 Aug 2014 20:18:02 -0700
Subject: msvc: resolve all warnings in VideoBackends/OGL.

---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 10ccf9fba8..311756d063 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -282,7 +282,7 @@ std::string OpenGLPostProcessing::LoadShaderOptions(const std::string& code)
 		}
 		else if (it.second.m_type == PostProcessingShaderConfiguration::ConfigurationOption::OptionType::OPTION_INTEGER)
 		{
-			u32 count = it.second.m_integer_values.size();
+			u32 count = static_cast<u32>(it.second.m_integer_values.size());
 			if (count == 1)
 				glsl_options += StringFromFormat("uniform int     option_%s;\n", it.first.c_str());
 			else
@@ -290,7 +290,7 @@ std::string OpenGLPostProcessing::LoadShaderOptions(const std::string& code)
 		}
 		else if (it.second.m_type == PostProcessingShaderConfiguration::ConfigurationOption::OptionType::OPTION_FLOAT)
 		{
-			u32 count = it.second.m_float_values.size();
+			u32 count = static_cast<u32>(it.second.m_float_values.size());
 			if (count == 1)
 				glsl_options += StringFromFormat("uniform float   option_%s;\n", it.first.c_str());
 			else
-- 
cgit v1.2.3


From ca68526ec776069669cf4fa0f11a917d9a9db877 Mon Sep 17 00:00:00 2001
From: Ryan Houdek <Sonicadvance1@gmail.com>
Date: Tue, 26 Aug 2014 07:08:37 -0500
Subject: Clear the texture used by PP shaders prior to use. We were generating
 a texture without ever setting the data to a known value. This happened on
 the old code as well, just that PP shaders are receiving some love and people
 are using it and noticing some of its issues.

---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 311756d063..648ed5c76a 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -55,7 +55,17 @@ OpenGLPostProcessing::~OpenGLPostProcessing()
 
 void OpenGLPostProcessing::BindTargetFramebuffer()
 {
-	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_enable ? m_fbo : 0);
+	if (m_enable)
+	{
+		glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fbo);
+		// Clear the buffer so there isn't any remaining garbage from the previous post processing shader frame
+		glClear(GL_COLOR_BUFFER_BIT);
+	}
+	else
+	{
+		// Bind to default framebuffer if we aren't post processing
+		glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
+	}
 }
 
 void OpenGLPostProcessing::BlitToScreen()
-- 
cgit v1.2.3


From 7292ea6a043d51907c9ce1d612f144aa65048350 Mon Sep 17 00:00:00 2001
From: degasus <wickmarkus@web.de>
Date: Sat, 18 Oct 2014 09:32:24 +0200
Subject: OGL: force enable postprocessing

---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 92 +++++++-----------------
 1 file changed, 24 insertions(+), 68 deletions(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 648ed5c76a..519406cb0f 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -19,65 +19,38 @@ namespace OGL
 
 static char s_vertex_shader[] =
 	"out vec2 uv0;\n"
+	"uniform vec4 src_rect;\n"
 	"void main(void) {\n"
 	"	vec2 rawpos = vec2(gl_VertexID&1, gl_VertexID&2);\n"
 	"	gl_Position = vec4(rawpos*2.0-1.0, 0.0, 1.0);\n"
-	"	uv0 = rawpos;\n"
+	"	uv0 = rawpos * src_rect.zw + src_rect.xy;\n"
 	"}\n";
 
 OpenGLPostProcessing::OpenGLPostProcessing()
 {
-	m_enable = false;
-	m_width = 0;
-	m_height = 0;
-
-	glGenFramebuffers(1, &m_fbo);
-	glGenTextures(1, &m_texture);
-	glBindTexture(GL_TEXTURE_2D, m_texture);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); // disable mipmaps
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
-	glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texture, 0);
-	FramebufferManager::SetFramebuffer(0);
-
 	CreateHeader();
+	m_initialized = false;
 }
 
 OpenGLPostProcessing::~OpenGLPostProcessing()
 {
 	m_shader.Destroy();
-
-	glDeleteFramebuffers(1, &m_fbo);
-	glDeleteTextures(1, &m_texture);
 }
 
-void OpenGLPostProcessing::BindTargetFramebuffer()
+void OpenGLPostProcessing::BlitFromTexture(TargetRectangle src, TargetRectangle dst,
+                                           int src_texture, int src_width, int src_height)
 {
-	if (m_enable)
-	{
-		glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fbo);
-		// Clear the buffer so there isn't any remaining garbage from the previous post processing shader frame
-		glClear(GL_COLOR_BUFFER_BIT);
-	}
-	else
-	{
-		// Bind to default framebuffer if we aren't post processing
-		glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
-	}
-}
-
-void OpenGLPostProcessing::BlitToScreen()
-{
-	if (!m_enable) return;
+	ApplyShader();
 
 	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
-	glViewport(0, 0, m_width, m_height);
+
+	glViewport(dst.left, dst.bottom, dst.GetWidth(), dst.GetHeight());
 
 	m_shader.Bind();
 
-	glUniform4f(m_uniform_resolution, (float)m_width, (float)m_height, 1.0f/(float)m_width, 1.0f/(float)m_height);
+	glUniform4f(m_uniform_resolution, (float)src_width, (float)src_height, 1.0f / (float)src_width, 1.0f / (float)src_height);
+	glUniform4f(m_uniform_src_rect, src.left / (float) src_width, src.bottom / (float) src_height,
+		    src.GetWidth() / (float) src_width, src.GetHeight() / (float) src_height);
 	glUniform1ui(m_uniform_time, (GLuint)m_timer.GetTimeElapsed());
 
 	if (m_config.IsDirty())
@@ -151,45 +124,27 @@ void OpenGLPostProcessing::BlitToScreen()
 	}
 
 	glActiveTexture(GL_TEXTURE0+9);
-	glBindTexture(GL_TEXTURE_2D, m_texture);
+	glBindTexture(GL_TEXTURE_2D, src_texture);
 	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 }
 
-void OpenGLPostProcessing::Update(u32 width, u32 height)
-{
-	ApplyShader();
-
-	if (m_enable && (width != m_width || height != m_height))
-	{
-		m_width = width;
-		m_height = height;
-
-		// alloc texture for framebuffer
-		glActiveTexture(GL_TEXTURE0+9);
-		glBindTexture(GL_TEXTURE_2D, m_texture);
-		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
-	}
-}
-
 void OpenGLPostProcessing::ApplyShader()
 {
 	// shader didn't changed
-	if (m_config.GetShader() == g_ActiveConfig.sPostProcessingShader)
+	if (m_initialized && m_config.GetShader() == g_ActiveConfig.sPostProcessingShader)
 		return;
 
-	m_enable = false;
 	m_shader.Destroy();
 	m_uniform_bindings.clear();
 
-	// shader disabled
-	if (g_ActiveConfig.sPostProcessingShader == "")
-		return;
-
-	// so need to compile shader
-	std::string code = m_config.LoadShader();
+	// load shader from disk
+	std::string default_shader = "void main() { SetOutput(Sample()); }";
+	std::string code = "";
+	if (g_ActiveConfig.sPostProcessingShader != "")
+		code = m_config.LoadShader();
 
 	if (code == "")
-		return;
+		code = default_shader;
 
 	code = LoadShaderOptions(code);
 
@@ -197,21 +152,22 @@ void OpenGLPostProcessing::ApplyShader()
 	if (!ProgramShaderCache::CompileShader(m_shader, s_vertex_shader, code.c_str()))
 	{
 		ERROR_LOG(VIDEO, "Failed to compile post-processing shader %s", m_config.GetShader().c_str());
-		return;
+
+		code = LoadShaderOptions(default_shader);
+		ProgramShaderCache::CompileShader(m_shader, s_vertex_shader, code.c_str());
 	}
 
 	// read uniform locations
 	m_uniform_resolution = glGetUniformLocation(m_shader.glprogid, "resolution");
 	m_uniform_time = glGetUniformLocation(m_shader.glprogid, "time");
+	m_uniform_src_rect = glGetUniformLocation(m_shader.glprogid, "src_rect");
 
 	for (const auto& it : m_config.GetOptions())
 	{
 		std::string glsl_name = "option_" + it.first;
 		m_uniform_bindings[it.first] = glGetUniformLocation(m_shader.glprogid, glsl_name.c_str());
 	}
-
-	// successful
-	m_enable = true;
+	m_initialized = true;
 }
 
 void OpenGLPostProcessing::CreateHeader()
-- 
cgit v1.2.3


From ce9ef2c438c4c5b0460554aa361bc0ab156174d1 Mon Sep 17 00:00:00 2001
From: degasus <wickmarkus@web.de>
Date: Mon, 27 Oct 2014 21:15:32 +0100
Subject: OGL: fix interpolation of PP shaders

---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 519406cb0f..f3017c326d 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -125,6 +125,8 @@ void OpenGLPostProcessing::BlitFromTexture(TargetRectangle src, TargetRectangle
 
 	glActiveTexture(GL_TEXTURE0+9);
 	glBindTexture(GL_TEXTURE_2D, src_texture);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 }
 
-- 
cgit v1.2.3


From 181ff6750ea4113378497beebf49400ba83a8e07 Mon Sep 17 00:00:00 2001
From: Ryan Houdek <Sonicadvance1@gmail.com>
Date: Wed, 29 Oct 2014 20:06:45 -0500
Subject: Implements PP shader system using attribute workaround.

This is pretty much a step backwards in our code. We used to use attributes in our PP shader system a long time ago but we changed it to attributeless
for code simplicity and cleanliness. This reimplements the attribute code path as an optional path to take in the case your system doesn't work with
attributeless rendering. In this case the only shipping drivers that we can know for sure supports attributeless rendering is the Nexus 5's v95 driver
that is included in the Android 5.0 image.

I hadn't planned on implementing a work around to get post processing working in these cases, but due to us force enabling the PP shader system at all
times it sort of went up on the priority list. We can't be having a supported platform black screening at all times can we?
---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 53 +++++++++++++++++++++++-
 1 file changed, 51 insertions(+), 2 deletions(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 519406cb0f..b364954bd7 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -11,12 +11,22 @@
 #include "VideoBackends/OGL/PostProcessing.h"
 #include "VideoBackends/OGL/ProgramShaderCache.h"
 
+#include "VideoCommon/DriverDetails.h"
 #include "VideoCommon/VideoCommon.h"
 #include "VideoCommon/VideoConfig.h"
 
 namespace OGL
 {
 
+static char s_vertex_workaround_shader[] =
+	"in vec4 rawpos;\n"
+	"out vec2 uv0;\n"
+	"uniform vec4 src_rect;\n"
+	"void main(void) {\n"
+	"	gl_Position = vec4(rawpos.xy, 0.0, 1.0);\n"
+	"	uv0 = rawpos.zw * src_rect.zw + src_rect.xy;\n"
+	"}\n";
+
 static char s_vertex_shader[] =
 	"out vec2 uv0;\n"
 	"uniform vec4 src_rect;\n"
@@ -29,12 +39,26 @@ static char s_vertex_shader[] =
 OpenGLPostProcessing::OpenGLPostProcessing()
 {
 	CreateHeader();
+
+	m_attribute_workaround = DriverDetails::HasBug(DriverDetails::BUG_BROKENATTRIBUTELESS);
+	if (m_attribute_workaround)
+	{
+		glGenBuffers(1, &m_attribute_vbo);
+		glGenVertexArrays(1, &m_attribute_vao);
+	}
+
 	m_initialized = false;
 }
 
 OpenGLPostProcessing::~OpenGLPostProcessing()
 {
 	m_shader.Destroy();
+
+	if (m_attribute_workaround)
+	{
+		glDeleteBuffers(1, &m_attribute_vbo);
+		glDeleteVertexArrays(1, &m_attribute_vao);
+	}
 }
 
 void OpenGLPostProcessing::BlitFromTexture(TargetRectangle src, TargetRectangle dst,
@@ -46,6 +70,9 @@ void OpenGLPostProcessing::BlitFromTexture(TargetRectangle src, TargetRectangle
 
 	glViewport(dst.left, dst.bottom, dst.GetWidth(), dst.GetHeight());
 
+	if (m_attribute_workaround)
+		glBindVertexArray(m_attribute_vao);
+
 	m_shader.Bind();
 
 	glUniform4f(m_uniform_resolution, (float)src_width, (float)src_height, 1.0f / (float)src_width, 1.0f / (float)src_height);
@@ -148,13 +175,18 @@ void OpenGLPostProcessing::ApplyShader()
 
 	code = LoadShaderOptions(code);
 
+	const char* vertex_shader = s_vertex_shader;
+
+	if (m_attribute_workaround)
+		vertex_shader = s_vertex_workaround_shader;
+
 	// and compile it
-	if (!ProgramShaderCache::CompileShader(m_shader, s_vertex_shader, code.c_str()))
+	if (!ProgramShaderCache::CompileShader(m_shader, vertex_shader, code.c_str()))
 	{
 		ERROR_LOG(VIDEO, "Failed to compile post-processing shader %s", m_config.GetShader().c_str());
 
 		code = LoadShaderOptions(default_shader);
-		ProgramShaderCache::CompileShader(m_shader, s_vertex_shader, code.c_str());
+		ProgramShaderCache::CompileShader(m_shader, vertex_shader, code.c_str());
 	}
 
 	// read uniform locations
@@ -162,6 +194,23 @@ void OpenGLPostProcessing::ApplyShader()
 	m_uniform_time = glGetUniformLocation(m_shader.glprogid, "time");
 	m_uniform_src_rect = glGetUniformLocation(m_shader.glprogid, "src_rect");
 
+	if (m_attribute_workaround)
+	{
+		GLfloat vertices[] = {
+			-1.f, -1.f, 0.f, 0.f,
+			 1.f, -1.f, 1.f, 0.f,
+			-1.f,  1.f, 0.f, 1.f,
+			 1.f,  1.f, 1.f, 1.f,
+		};
+
+		glBindBuffer(GL_ARRAY_BUFFER, m_attribute_vbo);
+		glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+
+		glBindVertexArray(m_attribute_vao);
+		glEnableVertexAttribArray(SHADER_POSITION_ATTRIB);
+		glVertexAttribPointer(SHADER_POSITION_ATTRIB, 4, GL_FLOAT, 0, 0, nullptr);
+	}
+
 	for (const auto& it : m_config.GetOptions())
 	{
 		std::string glsl_name = "option_" + it.first;
-- 
cgit v1.2.3


From c64486075d728b3682b77ed06d5c154fd4a5c88d Mon Sep 17 00:00:00 2001
From: Jules Blok <jules.blok@gmail.com>
Date: Wed, 22 Oct 2014 13:02:28 +0200
Subject: PostProcessing: Add layered stereoscopy support.

---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 434a1d94a3..2681fcd345 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -36,7 +36,7 @@ static char s_vertex_shader[] =
 	"	uv0 = rawpos * src_rect.zw + src_rect.xy;\n"
 	"}\n";
 
-OpenGLPostProcessing::OpenGLPostProcessing()
+OpenGLPostProcessing::OpenGLPostProcessing() : m_initialized(false)
 {
 	CreateHeader();
 
@@ -46,8 +46,6 @@ OpenGLPostProcessing::OpenGLPostProcessing()
 		glGenBuffers(1, &m_attribute_vbo);
 		glGenVertexArrays(1, &m_attribute_vao);
 	}
-
-	m_initialized = false;
 }
 
 OpenGLPostProcessing::~OpenGLPostProcessing()
@@ -62,7 +60,7 @@ OpenGLPostProcessing::~OpenGLPostProcessing()
 }
 
 void OpenGLPostProcessing::BlitFromTexture(TargetRectangle src, TargetRectangle dst,
-                                           int src_texture, int src_width, int src_height)
+                                           int src_texture, int src_width, int src_height, int layer)
 {
 	ApplyShader();
 
@@ -79,6 +77,7 @@ void OpenGLPostProcessing::BlitFromTexture(TargetRectangle src, TargetRectangle
 	glUniform4f(m_uniform_src_rect, src.left / (float) src_width, src.bottom / (float) src_height,
 		    src.GetWidth() / (float) src_width, src.GetHeight() / (float) src_height);
 	glUniform1ui(m_uniform_time, (GLuint)m_timer.GetTimeElapsed());
+	glUniform1i(m_uniform_layer, layer);
 
 	if (m_config.IsDirty())
 	{
@@ -151,9 +150,9 @@ void OpenGLPostProcessing::BlitFromTexture(TargetRectangle src, TargetRectangle
 	}
 
 	glActiveTexture(GL_TEXTURE0+9);
-	glBindTexture(GL_TEXTURE_2D, src_texture);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glBindTexture(GL_TEXTURE_2D_ARRAY, src_texture);
+	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 }
 
@@ -167,7 +166,7 @@ void OpenGLPostProcessing::ApplyShader()
 	m_uniform_bindings.clear();
 
 	// load shader from disk
-	std::string default_shader = "void main() { SetOutput(Sample()); }";
+	std::string default_shader = "void main() { SetOutput(Sample()); }\n";
 	std::string code = "";
 	if (g_ActiveConfig.sPostProcessingShader != "")
 		code = m_config.LoadShader();
@@ -195,6 +194,7 @@ void OpenGLPostProcessing::ApplyShader()
 	m_uniform_resolution = glGetUniformLocation(m_shader.glprogid, "resolution");
 	m_uniform_time = glGetUniformLocation(m_shader.glprogid, "time");
 	m_uniform_src_rect = glGetUniformLocation(m_shader.glprogid, "src_rect");
+	m_uniform_layer = glGetUniformLocation(m_shader.glprogid, "layer");
 
 	if (m_attribute_workaround)
 	{
@@ -228,7 +228,7 @@ void OpenGLPostProcessing::CreateHeader()
 		// Shouldn't be accessed directly by the PP shader
 		// Texture sampler
 		"SAMPLER_BINDING(8) uniform sampler2D samp8;\n"
-		"SAMPLER_BINDING(9) uniform sampler2D samp9;\n"
+		"SAMPLER_BINDING(9) uniform sampler2DArray samp9;\n"
 
 		// Output variable
 		"out float4 ocol0;\n"
@@ -238,16 +238,18 @@ void OpenGLPostProcessing::CreateHeader()
 		"uniform float4 resolution;\n"
 		// Time
 		"uniform uint time;\n"
+		// Layer
+		"uniform int layer;\n"
 
 		// Interfacing functions
 		"float4 Sample()\n"
 		"{\n"
-			"\treturn texture(samp9, uv0);\n"
+			"\treturn texture(samp9, float3(uv0, layer));\n"
 		"}\n"
 
 		"float4 SampleLocation(float2 location)\n"
 		"{\n"
-			"\treturn texture(samp9, location);\n"
+			"\treturn texture(samp9, float3(location, layer));\n"
 		"}\n"
 
 		"#define SampleOffset(offset) textureOffset(samp9, uv0, offset)\n"
-- 
cgit v1.2.3


From 4d9589b35f2629c558a9a7efdee3d66497fc0fc6 Mon Sep 17 00:00:00 2001
From: Jules Blok <jules.blok@gmail.com>
Date: Thu, 30 Oct 2014 15:13:31 +0100
Subject: Cosmetics.

---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 2681fcd345..7cd99a05d7 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -36,7 +36,8 @@ static char s_vertex_shader[] =
 	"	uv0 = rawpos * src_rect.zw + src_rect.xy;\n"
 	"}\n";
 
-OpenGLPostProcessing::OpenGLPostProcessing() : m_initialized(false)
+OpenGLPostProcessing::OpenGLPostProcessing()
+	: m_initialized(false)
 {
 	CreateHeader();
 
-- 
cgit v1.2.3


From c3ad6e78207bc0f64a9687fd8f27fbe0f7606bc7 Mon Sep 17 00:00:00 2001
From: Jules Blok <jules.blok@gmail.com>
Date: Fri, 31 Oct 2014 15:53:08 +0100
Subject: PostProcessing: Add support for anaglyph stereoscopy mode.

---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 7cd99a05d7..905531226c 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -166,10 +166,13 @@ void OpenGLPostProcessing::ApplyShader()
 	m_shader.Destroy();
 	m_uniform_bindings.clear();
 
-	// load shader from disk
-	std::string default_shader = "void main() { SetOutput(Sample()); }\n";
+	// load shader code
 	std::string code = "";
-	if (g_ActiveConfig.sPostProcessingShader != "")
+	std::string default_shader = "void main() { SetOutput(Sample()); }\n";
+
+	if (g_ActiveConfig.iStereoMode == STEREO_ANAGLYPH)
+		code = "void main() { SetOutput(float4(SampleLayer(1).r, SampleLayer(0).gba)); }\n";
+	else if (g_ActiveConfig.sPostProcessingShader != "")
 		code = m_config.LoadShader();
 
 	if (code == "")
@@ -253,7 +256,12 @@ void OpenGLPostProcessing::CreateHeader()
 			"\treturn texture(samp9, float3(location, layer));\n"
 		"}\n"
 
-		"#define SampleOffset(offset) textureOffset(samp9, uv0, offset)\n"
+		"float4 SampleLayer(int layer)\n"
+		"{\n"
+			"\treturn texture(samp9, float3(uv0, layer));\n"
+		"}\n"
+
+		"#define SampleOffset(offset) textureOffset(samp9, float3(uv0, layer), offset)\n"
 
 		"float4 SampleFontLocation(float2 location)\n"
 		"{\n"
-- 
cgit v1.2.3


From ab76cf8b5e27eee916107e3f6ddf209407ce169d Mon Sep 17 00:00:00 2001
From: Jules Blok <jules.blok@gmail.com>
Date: Sat, 1 Nov 2014 23:01:22 +0100
Subject: PostProcessing: Apply color correction to the anaglyph shader.

The eyes were accidentally swapped, the left filter only allows red to pass so the left eye texture should be used in the red channel.
---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 905531226c..84088459ed 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -171,7 +171,7 @@ void OpenGLPostProcessing::ApplyShader()
 	std::string default_shader = "void main() { SetOutput(Sample()); }\n";
 
 	if (g_ActiveConfig.iStereoMode == STEREO_ANAGLYPH)
-		code = "void main() { SetOutput(float4(SampleLayer(1).r, SampleLayer(0).gba)); }\n";
+		code = "void main() { SetOutput(float4(pow(0.7 * SampleLayer(0).g + 0.3 * SampleLayer(0).b, 1.5), SampleLayer(1).gba)); }\n";
 	else if (g_ActiveConfig.sPostProcessingShader != "")
 		code = m_config.LoadShader();
 
-- 
cgit v1.2.3


From 9994ccb3422b88649eb160bf373d4d29b08a4768 Mon Sep 17 00:00:00 2001
From: Jules Blok <jules.blok@gmail.com>
Date: Sat, 8 Nov 2014 15:08:41 +0100
Subject: PostProcessing: Invalidate shader when anaglyph stereoscopy is
 toggled.

---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 84088459ed..80bdf8eef4 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -38,6 +38,7 @@ static char s_vertex_shader[] =
 
 OpenGLPostProcessing::OpenGLPostProcessing()
 	: m_initialized(false)
+	, m_anaglyph(false)
 {
 	CreateHeader();
 
@@ -160,7 +161,8 @@ void OpenGLPostProcessing::BlitFromTexture(TargetRectangle src, TargetRectangle
 void OpenGLPostProcessing::ApplyShader()
 {
 	// shader didn't changed
-	if (m_initialized && m_config.GetShader() == g_ActiveConfig.sPostProcessingShader)
+	if (m_initialized && m_config.GetShader() == g_ActiveConfig.sPostProcessingShader &&
+			((g_ActiveConfig.iStereoMode == STEREO_ANAGLYPH) == m_anaglyph))
 		return;
 
 	m_shader.Destroy();
@@ -222,6 +224,7 @@ void OpenGLPostProcessing::ApplyShader()
 		std::string glsl_name = "option_" + it.first;
 		m_uniform_bindings[it.first] = glGetUniformLocation(m_shader.glprogid, glsl_name.c_str());
 	}
+	m_anaglyph = g_ActiveConfig.iStereoMode == STEREO_ANAGLYPH;
 	m_initialized = true;
 }
 
-- 
cgit v1.2.3


From b19cff8a08a03b39653ea16ec5f51a2c80c5f2d1 Mon Sep 17 00:00:00 2001
From: "Unknown W. Brackets" <checkins@unknownbrackets.org>
Date: Wed, 3 Dec 2014 23:24:58 -0800
Subject: OGL: Use a fixed VAO for attributeless rendering.

Instead of abusing whatever VAO is previously bound, which might have
enabled arrays.

Only used in one instance currently, which fixes a crash with older
NVIDIA drivers.
---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 80bdf8eef4..74fd93147b 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -72,6 +72,8 @@ void OpenGLPostProcessing::BlitFromTexture(TargetRectangle src, TargetRectangle
 
 	if (m_attribute_workaround)
 		glBindVertexArray(m_attribute_vao);
+	else
+		OpenGL_BindAttributelessVAO();
 
 	m_shader.Bind();
 
-- 
cgit v1.2.3


From e3969f763e62ff5c8a83b2996672b321ed9174ea Mon Sep 17 00:00:00 2001
From: Jules Blok <jules.blok@gmail.com>
Date: Fri, 2 Jan 2015 02:58:52 +0100
Subject: PostProcessing: Use Dubois algorithm for anaglyph shader.

---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 30 ++++++++++++++++++++----
 1 file changed, 25 insertions(+), 5 deletions(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 74fd93147b..cbcd1b0e9c 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -36,6 +36,28 @@ static char s_vertex_shader[] =
 	"	uv0 = rawpos * src_rect.zw + src_rect.xy;\n"
 	"}\n";
 
+// Anaglyph Red-Cyan shader based on Dubois algorithm
+// Constants taken from the paper:
+// "Conversion of a Stereo Pair to Anaglyph with
+// the Least-Squares Projection Method"
+// Eric Dubois, March 2009
+static char s_anaglyph_shader[] =
+	"void main() {\n"
+	"	vec3 l = SampleLayer(0).rgb;\n"
+	"	vec3 r = SampleLayer(1).rgb;\n"
+	"	vec3 lr = vec3(0.437,0.449,0.164);\n"
+	"	vec3 lg = vec3(-0.062,-0.062,-0.024);\n"
+	"	vec3 lb = vec3(-0.048,-0.050,-0.017);\n"
+	"	vec3 rr = vec3(-0.011,-0.032,-0.007);\n"
+	"	vec3 rg = vec3(0.377,0.761,0.009);\n"
+	"	vec3 rb = vec3(-0.026,-0.093,1.234);\n"
+	"	vec3 c0 = vec3(dot(l, lr), dot(l, lg), dot(l, lb));\n"
+	"	vec3 c1 = vec3(dot(r, rr), dot(r, rg), dot(r, rb));\n"
+	"	SetOutput(vec4(c0 + c1, SampleLayer(0).a));\n"
+	"}\n";
+
+static const char s_default_shader[] = "void main() { SetOutput(Sample()); }\n";
+
 OpenGLPostProcessing::OpenGLPostProcessing()
 	: m_initialized(false)
 	, m_anaglyph(false)
@@ -172,15 +194,13 @@ void OpenGLPostProcessing::ApplyShader()
 
 	// load shader code
 	std::string code = "";
-	std::string default_shader = "void main() { SetOutput(Sample()); }\n";
-
 	if (g_ActiveConfig.iStereoMode == STEREO_ANAGLYPH)
-		code = "void main() { SetOutput(float4(pow(0.7 * SampleLayer(0).g + 0.3 * SampleLayer(0).b, 1.5), SampleLayer(1).gba)); }\n";
+		code = s_anaglyph_shader;
 	else if (g_ActiveConfig.sPostProcessingShader != "")
 		code = m_config.LoadShader();
 
 	if (code == "")
-		code = default_shader;
+		code = s_default_shader;
 
 	code = LoadShaderOptions(code);
 
@@ -194,7 +214,7 @@ void OpenGLPostProcessing::ApplyShader()
 	{
 		ERROR_LOG(VIDEO, "Failed to compile post-processing shader %s", m_config.GetShader().c_str());
 
-		code = LoadShaderOptions(default_shader);
+		code = LoadShaderOptions(s_default_shader);
 		ProgramShaderCache::CompileShader(m_shader, vertex_shader, code.c_str());
 	}
 
-- 
cgit v1.2.3


From 26a9afa0e7f3f1d8443062c0149cf461412f4ecb Mon Sep 17 00:00:00 2001
From: Jules Blok <jules.blok@gmail.com>
Date: Fri, 2 Jan 2015 13:35:53 +0100
Subject: Anaglyph: Use matrices instead of vectors.

---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index cbcd1b0e9c..16a50cf2de 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -43,17 +43,15 @@ static char s_vertex_shader[] =
 // Eric Dubois, March 2009
 static char s_anaglyph_shader[] =
 	"void main() {\n"
-	"	vec3 l = SampleLayer(0).rgb;\n"
-	"	vec3 r = SampleLayer(1).rgb;\n"
-	"	vec3 lr = vec3(0.437,0.449,0.164);\n"
-	"	vec3 lg = vec3(-0.062,-0.062,-0.024);\n"
-	"	vec3 lb = vec3(-0.048,-0.050,-0.017);\n"
-	"	vec3 rr = vec3(-0.011,-0.032,-0.007);\n"
-	"	vec3 rg = vec3(0.377,0.761,0.009);\n"
-	"	vec3 rb = vec3(-0.026,-0.093,1.234);\n"
-	"	vec3 c0 = vec3(dot(l, lr), dot(l, lg), dot(l, lb));\n"
-	"	vec3 c1 = vec3(dot(r, rr), dot(r, rg), dot(r, rb));\n"
-	"	SetOutput(vec4(c0 + c1, SampleLayer(0).a));\n"
+	"	vec4 c0 = SampleLayer(0);\n"
+	"	vec4 c1 = SampleLayer(1);\n"
+	"	mat3 l = mat3( 0.437, 0.449, 0.164,\n"
+	"	              -0.062,-0.062,-0.024,\n"
+	"	              -0.048,-0.050,-0.017);\n"
+	"	mat3 r = mat3(-0.011,-0.032,-0.007,\n"
+	"	               0.377, 0.761, 0.009,\n"
+	"	              -0.026,-0.093, 1.234);\n"
+	"	SetOutput(vec4(c0.rgb * l + c1.rgb * r, c0.a));\n"
 	"}\n";
 
 static const char s_default_shader[] = "void main() { SetOutput(Sample()); }\n";
-- 
cgit v1.2.3


From 582a15deb38a0510eded144be843f737ed51cca8 Mon Sep 17 00:00:00 2001
From: Jules Blok <jules.blok@gmail.com>
Date: Fri, 2 Jan 2015 20:03:20 +0100
Subject: PostProcessing: Mark all shaders constant.

---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 16a50cf2de..3c1bb386bf 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -18,7 +18,7 @@
 namespace OGL
 {
 
-static char s_vertex_workaround_shader[] =
+static const char s_vertex_workaround_shader[] =
 	"in vec4 rawpos;\n"
 	"out vec2 uv0;\n"
 	"uniform vec4 src_rect;\n"
@@ -27,7 +27,7 @@ static char s_vertex_workaround_shader[] =
 	"	uv0 = rawpos.zw * src_rect.zw + src_rect.xy;\n"
 	"}\n";
 
-static char s_vertex_shader[] =
+static const char s_vertex_shader[] =
 	"out vec2 uv0;\n"
 	"uniform vec4 src_rect;\n"
 	"void main(void) {\n"
@@ -41,7 +41,7 @@ static char s_vertex_shader[] =
 // "Conversion of a Stereo Pair to Anaglyph with
 // the Least-Squares Projection Method"
 // Eric Dubois, March 2009
-static char s_anaglyph_shader[] =
+static const char s_anaglyph_shader[] =
 	"void main() {\n"
 	"	vec4 c0 = SampleLayer(0);\n"
 	"	vec4 c1 = SampleLayer(1);\n"
-- 
cgit v1.2.3


From 262c3b19ecf9a4c022b3667613f892a5539dd34d Mon Sep 17 00:00:00 2001
From: Jules Blok <jules.blok@gmail.com>
Date: Sat, 3 Jan 2015 01:33:30 +0100
Subject: PostProcessing: Add support for user-supplied anaglyph shaders.

There are lots of different anaglyph glasses out there and there may be even more creative uses for stereoscopic post-processing shaders.
---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 27 ++----------------------
 1 file changed, 2 insertions(+), 25 deletions(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 3c1bb386bf..3fa6f26de9 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -36,29 +36,10 @@ static const char s_vertex_shader[] =
 	"	uv0 = rawpos * src_rect.zw + src_rect.xy;\n"
 	"}\n";
 
-// Anaglyph Red-Cyan shader based on Dubois algorithm
-// Constants taken from the paper:
-// "Conversion of a Stereo Pair to Anaglyph with
-// the Least-Squares Projection Method"
-// Eric Dubois, March 2009
-static const char s_anaglyph_shader[] =
-	"void main() {\n"
-	"	vec4 c0 = SampleLayer(0);\n"
-	"	vec4 c1 = SampleLayer(1);\n"
-	"	mat3 l = mat3( 0.437, 0.449, 0.164,\n"
-	"	              -0.062,-0.062,-0.024,\n"
-	"	              -0.048,-0.050,-0.017);\n"
-	"	mat3 r = mat3(-0.011,-0.032,-0.007,\n"
-	"	               0.377, 0.761, 0.009,\n"
-	"	              -0.026,-0.093, 1.234);\n"
-	"	SetOutput(vec4(c0.rgb * l + c1.rgb * r, c0.a));\n"
-	"}\n";
-
 static const char s_default_shader[] = "void main() { SetOutput(Sample()); }\n";
 
 OpenGLPostProcessing::OpenGLPostProcessing()
 	: m_initialized(false)
-	, m_anaglyph(false)
 {
 	CreateHeader();
 
@@ -183,8 +164,7 @@ void OpenGLPostProcessing::BlitFromTexture(TargetRectangle src, TargetRectangle
 void OpenGLPostProcessing::ApplyShader()
 {
 	// shader didn't changed
-	if (m_initialized && m_config.GetShader() == g_ActiveConfig.sPostProcessingShader &&
-			((g_ActiveConfig.iStereoMode == STEREO_ANAGLYPH) == m_anaglyph))
+	if (m_initialized && m_config.GetShader() == g_ActiveConfig.sPostProcessingShader)
 		return;
 
 	m_shader.Destroy();
@@ -192,9 +172,7 @@ void OpenGLPostProcessing::ApplyShader()
 
 	// load shader code
 	std::string code = "";
-	if (g_ActiveConfig.iStereoMode == STEREO_ANAGLYPH)
-		code = s_anaglyph_shader;
-	else if (g_ActiveConfig.sPostProcessingShader != "")
+	if (g_ActiveConfig.sPostProcessingShader != "")
 		code = m_config.LoadShader();
 
 	if (code == "")
@@ -244,7 +222,6 @@ void OpenGLPostProcessing::ApplyShader()
 		std::string glsl_name = "option_" + it.first;
 		m_uniform_bindings[it.first] = glGetUniformLocation(m_shader.glprogid, glsl_name.c_str());
 	}
-	m_anaglyph = g_ActiveConfig.iStereoMode == STEREO_ANAGLYPH;
 	m_initialized = true;
 }
 
-- 
cgit v1.2.3


From 5c4ee2f71e2e1c80ba2bf829751f1202f6e65ee9 Mon Sep 17 00:00:00 2001
From: Jules Blok <jules.blok@gmail.com>
Date: Sun, 25 Jan 2015 23:08:49 +0100
Subject: PostProcessing: Move default pixel shader to
 PostProcessingShaderConfiguration.

Reduces code complexity and fixes a bug where the shader is not properly invalidated.
---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 14 +++-----------
 1 file changed, 3 insertions(+), 11 deletions(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 3fa6f26de9..b03dc940be 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -36,8 +36,6 @@ static const char s_vertex_shader[] =
 	"	uv0 = rawpos * src_rect.zw + src_rect.xy;\n"
 	"}\n";
 
-static const char s_default_shader[] = "void main() { SetOutput(Sample()); }\n";
-
 OpenGLPostProcessing::OpenGLPostProcessing()
 	: m_initialized(false)
 {
@@ -171,13 +169,7 @@ void OpenGLPostProcessing::ApplyShader()
 	m_uniform_bindings.clear();
 
 	// load shader code
-	std::string code = "";
-	if (g_ActiveConfig.sPostProcessingShader != "")
-		code = m_config.LoadShader();
-
-	if (code == "")
-		code = s_default_shader;
-
+	std::string code = m_config.LoadShader();
 	code = LoadShaderOptions(code);
 
 	const char* vertex_shader = s_vertex_shader;
@@ -189,8 +181,8 @@ void OpenGLPostProcessing::ApplyShader()
 	if (!ProgramShaderCache::CompileShader(m_shader, vertex_shader, code.c_str()))
 	{
 		ERROR_LOG(VIDEO, "Failed to compile post-processing shader %s", m_config.GetShader().c_str());
-
-		code = LoadShaderOptions(s_default_shader);
+		g_ActiveConfig.sPostProcessingShader.clear();
+		code = m_config.LoadShader();
 		ProgramShaderCache::CompileShader(m_shader, vertex_shader, code.c_str());
 	}
 
-- 
cgit v1.2.3


From cefcb0ace9d363b3679b4e93bcc9ec05f1e5f4f8 Mon Sep 17 00:00:00 2001
From: Tillmann Karras <tilkax@gmail.com>
Date: Mon, 18 May 2015 01:08:10 +0200
Subject: Update license headers to GPLv2+

---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index b03dc940be..2b2166002c 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -1,5 +1,5 @@
 // Copyright 2013 Dolphin Emulator Project
-// Licensed under GPLv2
+// Licensed under GPLv2+
 // Refer to the license.txt file included.
 
 #include "Common/CommonPaths.h"
-- 
cgit v1.2.3


From 30ebb2459eb97ba544547183854775df8460b475 Mon Sep 17 00:00:00 2001
From: Tillmann Karras <tilkax@gmail.com>
Date: Sun, 24 May 2015 06:55:12 +0200
Subject: Set copyright year to when a file was created

---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 2b2166002c..af26e398fb 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -1,4 +1,4 @@
-// Copyright 2013 Dolphin Emulator Project
+// Copyright 2009 Dolphin Emulator Project
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
-- 
cgit v1.2.3


From 285ac34bf3bada1737dd1e0a2f30af575435828e Mon Sep 17 00:00:00 2001
From: Tillmann Karras <tilkax@gmail.com>
Date: Mon, 25 May 2015 15:14:20 +0200
Subject: OGL: use GL_TEXTURE* constants

---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index af26e398fb..92ca734398 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -152,7 +152,7 @@ void OpenGLPostProcessing::BlitFromTexture(TargetRectangle src, TargetRectangle
 		m_config.SetDirty(false);
 	}
 
-	glActiveTexture(GL_TEXTURE0+9);
+	glActiveTexture(GL_TEXTURE9);
 	glBindTexture(GL_TEXTURE_2D_ARRAY, src_texture);
 	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-- 
cgit v1.2.3


From c4fc141ced900bfa73b06155e5e566df131e2f67 Mon Sep 17 00:00:00 2001
From: degasus <wickmarkus@web.de>
Date: Fri, 29 May 2015 00:53:07 +0200
Subject: OGL: Always use sampler objects.

We are used to use the texture parameter for all util draw calls,
but AMD seems to have a bug where they use the sampler parameter
of stage 0 if no sampler is bound to the used stage.
So as workaround (and a bit as nicer code), we now use sampler
objects everywhere.
---
 Source/Core/VideoBackends/OGL/PostProcessing.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'Source/Core/VideoBackends/OGL/PostProcessing.cpp')

diff --git a/Source/Core/VideoBackends/OGL/PostProcessing.cpp b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
index 92ca734398..b6715ff0ff 100644
--- a/Source/Core/VideoBackends/OGL/PostProcessing.cpp
+++ b/Source/Core/VideoBackends/OGL/PostProcessing.cpp
@@ -10,6 +10,7 @@
 #include "VideoBackends/OGL/GLUtil.h"
 #include "VideoBackends/OGL/PostProcessing.h"
 #include "VideoBackends/OGL/ProgramShaderCache.h"
+#include "VideoBackends/OGL/SamplerCache.h"
 
 #include "VideoCommon/DriverDetails.h"
 #include "VideoCommon/VideoCommon.h"
@@ -154,8 +155,7 @@ void OpenGLPostProcessing::BlitFromTexture(TargetRectangle src, TargetRectangle
 
 	glActiveTexture(GL_TEXTURE9);
 	glBindTexture(GL_TEXTURE_2D_ARRAY, src_texture);
-	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	g_sampler_cache->BindLinearSampler(9);
 	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 }
 
-- 
cgit v1.2.3