Differential D9848 Diff 25643 effects/blur/blurshader.cpp

Changeset View

Standalone View

effects/blur/blurshader.cpp

1	/*	1		/*
2	* Copyright © 2010 Fredrik Höglund <fredrik@kde.org>	2		* Copyright © 2010 Fredrik Höglund <fredrik@kde.org>
		3		* Copyright © 2018 Alex Nemeth <alex.nemeth329@gmail.com>
3	*	4		*
4	* This program is free software; you can redistribute it and/or modify	5		* This program is free software; you can redistribute it and/or modify
5	* it under the terms of the GNU General Public License as published by	6		* it under the terms of the GNU General Public License as published by
6	* the Free Software Foundation; either version 2 of the License, or	7		* the Free Software Foundation; either version 2 of the License, or
7	* (at your option) any later version.	8		* (at your option) any later version.
8	*	9		*
9	* This program is distributed in the hope that it will be useful,	10		* This program is distributed in the hope that it will be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of	11		* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	12		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12	* General Public License for more details.	13		* General Public License for more details.
13	*	14		*
14	* You should have received a copy of the GNU General Public License	15		* You should have received a copy of the GNU General Public License
15	* along with this program; see the file COPYING. if not, write to	16		* along with this program; see the file COPYING. if not, write to
16	* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,	17		* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17	* Boston, MA 02110-1301, USA.	18		* Boston, MA 02110-1301, USA.
18	*/	19		*/
19		20
20	#include "blurshader.h"	21		#include "blurshader.h"
21		22
22	#include <kwineffects.h>	23		#include <kwineffects.h>
		24		#include "kwinglutils.h"
23	#include <kwinglplatform.h>	25		#include <kwinglplatform.h>
24		26
25	#include <QByteArray>	27		#include <QByteArray>
26	#include <QMatrix4x4>	28		#include <QMatrix4x4>
27	#include <QTextStream>	29		#include <QTextStream>
28	#include <QVector2D>	30		#include <QVector2D>
29		31
30	#include <cmath>	32		#include <cmath>
31		33
32	using namespace KWin;	34		using namespace KWin;
33		35
34		36
35	BlurShader::BlurShader()	37		BlurShader::BlurShader()
36	: mRadius(0), mValid(false)	38		: mValid(false)
37	{	39		{
38	}	40		}
39		41
40	BlurShader::~BlurShader()	42		BlurShader::~BlurShader()
41	{	43		{
42	}	44		}
43		45
44	BlurShader *BlurShader::create()	46		BlurShader *BlurShader::create()
45	{	47		{
46	return new GLSLBlurShader();	48		return new GLSLBlurShader();
47	}	49		}
48		50
49	void BlurShader::setRadius(int radius)	51		// ----------------------------------------------------------------------------
50	{	52
51	const int r = qMax(radius, 2);
52		53
53	if (mRadius != r) {
54	mRadius = r;
55	reset();
56	init();
57	}
58	}
59		54
60	void BlurShader::setDirection(Qt::Orientation direction)	55		GLSLBlurShader::GLSLBlurShader()
61	{	56		{
62	mDirection = direction;	57		init();
63	}	58		}
64		59
			zzagUnsubmitted Done No, it should be in the header file. E.g. ... private: GLShader m_shaderDownsample = nullptr; GLShader m_shaderUpsample = nullptr; GLShader m_shaderCopysample = nullptr; ... zzag:* No, it should be in the header file. E.g. ``` ... private: GLShader *m_shaderDownsample =…
65	float BlurShader::gaussian(float x, float sigma) const	60		GLSLBlurShader::~GLSLBlurShader()
66	{	61		{
67	return (1.0 / std::sqrt(2.0 * M_PI) * sigma)	62		reset();
68	* std::exp(-((x * x) / (2.0 * sigma * sigma)));
69	}	63		}
70		64
71	QList<KernelValue> BlurShader::gaussianKernel() const	65		void GLSLBlurShader::reset()
72	{	66		{
73	int size = qMin(mRadius \| 1, maxKernelSize());	67		delete m_shaderDownsample;
74	if (!(size & 0x1))	68		m_shaderDownsample = nullptr;
75	size -= 1;	69
		70		delete m_shaderUpsample;
		71		m_shaderUpsample = nullptr;
76		72
77	QList<KernelValue> kernel;	73		delete m_shaderCopysample;
78	const int center = size / 2;	74		m_shaderCopysample = nullptr;
79	const qreal sigma = (size - 1) / 2.5;
80		75
81	kernel << KernelValue(0.0, gaussian(0.0, sigma));	76		setIsValid(false);
82	float total = kernel[0].g;	77		}
83		78
84	for (int x = 1; x <= center; x++) {	79		void GLSLBlurShader::setModelViewProjectionMatrix(const QMatrix4x4 &matrix)
85	const float fx = (x - 1) * 2 + 1.5;	80		{
86	const float g1 = gaussian(fx - 0.5, sigma);	81		if (!isValid())
87	const float g2 = gaussian(fx + 0.5, sigma);	82		return;
88		83
89	// Offset taking the contribution of both pixels into account	84		switch (m_activeSampleType) {
90	const float offset = .5 - g1 / (g1 + g2);	85		case CopySampleType:
		86		if (matrix == m_matrixCopysample)
		87		return;
91		88
92	kernel << KernelValue(fx + offset, g1 + g2);	89		m_matrixCopysample = matrix;
93	kernel << KernelValue(-(fx + offset), g1 + g2);	90		m_shaderCopysample->setUniform(m_mvpMatrixLocationCopysample, matrix);
		91		break;
94		92
95	total += (g1 + g2) * 2;	93		case UpSampleType:
96	}	94		if (matrix == m_matrixUpsample)
		95		return;
97		96
98	qSort(kernel);	97		m_matrixUpsample = matrix;
		98		m_shaderUpsample->setUniform(m_mvpMatrixLocationUpsample, matrix);
		99		break;
99		100
100	// Normalize the kernel	101		case DownSampleType:
101	for (int i = 0; i < kernel.count(); i++)	102		if (matrix == m_matrixDownsample)
102	kernel[i].g /= total;	103		return;
103		104
104	return kernel;	105		m_matrixDownsample = matrix;
		106		m_shaderDownsample->setUniform(m_mvpMatrixLocationDownsample, matrix);
		107		break;
		108		}
105	}	109		}
106		110
		111		void GLSLBlurShader::setOffset(float offset)
		112		{
		113		if (!isValid())
		114		return;
107		115
		116		switch (m_activeSampleType) {
		117		case UpSampleType:
		118		if (offset == m_offsetUpsample)
		119		return;
108		120
109	// ----------------------------------------------------------------------------	121		m_offsetUpsample = offset;
110		122		m_shaderUpsample->setUniform(m_offsetLocationUpsample, offset);
		123		break;
111		124
		125		case DownSampleType:
		126		if (offset == m_offsetDownsample)
		127		return;
112		128
113	GLSLBlurShader::GLSLBlurShader()	129		m_offsetDownsample = offset;
			zzagUnsubmitted Done You can simplify: GLShader m_shaderDownsample = nullptr; GLShader m_shaderUpsample = nullptr; GLShader m_shaderCopysample = nullptr; zzag:* You can simplify: ``` GLShader *m_shaderDownsample = nullptr; GLShader…
114	: BlurShader(), shader(NULL)	130		m_shaderDownsample->setUniform(m_offsetLocationDownsample, offset);
115	{	131		break;
116	}	132		}
117
118	GLSLBlurShader::~GLSLBlurShader()
119	{
120	reset();
121	}	133		}
122		134
123	void GLSLBlurShader::reset()	135		void GLSLBlurShader::setTargetSize(QSize renderTextureSize)
124	{	136		{
125	delete shader;	137		if (!isValid())
126	shader = NULL;	138		return;
127		139
128	setIsValid(false);	140		QVector2D texSize = QVector2D(renderTextureSize.width(), renderTextureSize.height());
129	}
130		141
			zzagUnsubmitted Done `nullptr` zzag: `nullptr`
131	void GLSLBlurShader::setPixelDistance(float val)	142		switch (m_activeSampleType) {
132	{	143		case CopySampleType:
133	if (!isValid())	144		if (renderTextureSize == m_renderTextureSizeCopysample)
			zzagUnsubmitted Done `nullptr` zzag: `nullptr`
134	return;	145		return;
135		146
136	QVector2D pixelSize(0.0, 0.0);	147		m_renderTextureSizeCopysample = renderTextureSize;
			zzagUnsubmitted Done `nullptr` zzag: `nullptr`
137	if (direction() == Qt::Horizontal)	148		m_shaderCopysample->setUniform(m_renderTextureSizeLocationCopysample, texSize);
138	pixelSize.setX(val);	149		break;
139	else
140	pixelSize.setY(val);
141		150
142	shader->setUniform(pixelSizeLocation, pixelSize);	151		case UpSampleType:
143	}	152		if (renderTextureSize == m_renderTextureSizeUpsample)
		153		return;
144		154
145	void GLSLBlurShader::setTextureMatrix(const QMatrix4x4 &matrix)	155		m_renderTextureSizeUpsample = renderTextureSize;
146	{	156		m_shaderUpsample->setUniform(m_renderTextureSizeLocationUpsample, texSize);
147	if (!isValid())	157		m_shaderUpsample->setUniform(m_halfpixelLocationUpsample, QVector2D(0.5 / texSize.x(), 0.5 / texSize.y()));
			zzagUnsubmitted Not Done Please use `{}` zzag: Please use `{}`
			anemethAuthorUnsubmitted Not Done Most other if statements don't use brackets when there is only a return line and I don't intend to break that tradition, or I might have to correct all of them too. anemeth: Most other if statements don't use brackets when there is only a return line and I don't intend…
		158		break;
		159
		160		case DownSampleType:
		161		if (renderTextureSize == m_renderTextureSizeDownsample)
148	return;	162		return;
149		163
150	shader->setUniform(textureMatrixLocation, matrix);	164		m_renderTextureSizeDownsample = renderTextureSize;
		165		m_shaderDownsample->setUniform(m_renderTextureSizeLocationDownsample, texSize);
		166		m_shaderDownsample->setUniform(m_halfpixelLocationDownsample, QVector2D(0.5 / texSize.x(), 0.5 / texSize.y()));
		167		break;
		168		}
151	}	169		}
152		170
153	void GLSLBlurShader::setModelViewProjectionMatrix(const QMatrix4x4 &matrix)	171		void GLSLBlurShader::setBlurRect(QRect blurRect, QSize screenSize)
154	{	172		{
155	if (!isValid())	173		if (!isValid() \|\| blurRect == m_blurRectCopysample)
156	return;	174		return;
157		175
158	shader->setUniform(mvpMatrixLocation, matrix);	176		m_blurRectCopysample = blurRect;
		177
		178		QVector4D rect = QVector4D(
		179		blurRect.bottomLeft().x() / float(screenSize.width()),
		180		1.0 - blurRect.bottomLeft().y() / float(screenSize.height()),
		181		blurRect.topRight().x() / float(screenSize.width()),
		182		1.0 - blurRect.topRight().y() / float(screenSize.height())
		183		);
		184
		185		m_shaderCopysample->setUniform(m_blurRectLocationCopysample, rect);
159	}	186		}
160		187
161	void GLSLBlurShader::bind()	188		void GLSLBlurShader::bind(SampleType sampleType)
162	{	189		{
163	if (!isValid())	190		if (!isValid())
164	return;	191		return;
165		192
166	ShaderManager::instance()->pushShader(shader);	193		switch (sampleType) {
		194		case CopySampleType:
		195		ShaderManager::instance()->pushShader(m_shaderCopysample);
		196		break;
		197
		198		case UpSampleType:
		199		ShaderManager::instance()->pushShader(m_shaderUpsample);
		200		break;
		201
		202		case DownSampleType:
		203		ShaderManager::instance()->pushShader(m_shaderDownsample);
		204		break;
167	}	205		}
168		206
169	void GLSLBlurShader::unbind()	207		m_activeSampleType = sampleType;
170	{
171	ShaderManager::instance()->popShader();
172	}	208		}
173		209
174	int GLSLBlurShader::maxKernelSize() const	210		void GLSLBlurShader::unbind()
175	{	211		{
176	if (GLPlatform::instance()->isGLES()) {	212		ShaderManager::instance()->popShader();
177	// GL_MAX_VARYING_FLOATS not available in GLES
178	// querying for GL_MAX_VARYING_VECTORS crashes on nouveau
179	// using the minimum value of 8
180	return 8 * 2;
181	} else {
182	int value;
183	glGetIntegerv(GL_MAX_VARYING_FLOATS, &value);
184	// Maximum number of vec4 varyings * 2
185	// The code generator will pack two vec2's into each vec4.
186	return value / 2;
187	}
188	}	213		}
189		214
190	void GLSLBlurShader::init()	215		void GLSLBlurShader::init()
191	{	216		{
192	QList<KernelValue> kernel = gaussianKernel();
193	const int size = kernel.size();
194	const int center = size / 2;
195
196	QList<QVector4D> offsets;
197	for (int i = 0; i < kernel.size(); i += 2) {
198	QVector4D vec4(0, 0, 0, 0);
199
200	vec4.setX(kernel[i].x);
201	vec4.setY(kernel[i].x);
202
203	if (i < kernel.size() - 1) {
204	vec4.setZ(kernel[i + 1].x);
205	vec4.setW(kernel[i + 1].x);
206	}
207
208	offsets << vec4;
209	}
210
211	const bool gles = GLPlatform::instance()->isGLES();	217		const bool gles = GLPlatform::instance()->isGLES();
212	const bool glsl_140 = !gles && GLPlatform::instance()->glslVersion() >= kVersionNumber(1, 40);	218		const bool glsl_140 = !gles && GLPlatform::instance()->glslVersion() >= kVersionNumber(1, 40);
213	const bool core = glsl_140 \|\| (gles && GLPlatform::instance()->glslVersion() >= kVersionNumber(3, 0));	219		const bool core = glsl_140 \|\| (gles && GLPlatform::instance()->glslVersion() >= kVersionNumber(3, 0));
214		220
215	QByteArray vertexSource;	221		QByteArray vertexSource;
216	QByteArray fragmentSource;	222		QByteArray fragmentDownSource;
		223		QByteArray fragmentUpSource;
		224		QByteArray fragmentCopySource;
217		225
218	const QByteArray attribute = core ? "in" : "attribute";	226		const QByteArray attribute = core ? "in" : "attribute";
219	const QByteArray varying_in = core ? (gles ? "in" : "noperspective in") : "varying";
220	const QByteArray varying_out = core ? (gles ? "out" : "noperspective out") : "varying";
221	const QByteArray texture2D = core ? "texture" : "texture2D";	227		const QByteArray texture2D = core ? "texture" : "texture2D";
222	const QByteArray fragColor = core ? "fragColor" : "gl_FragColor";	228		const QByteArray fragColor = core ? "fragColor" : "gl_FragColor";
223		229
224	// Vertex shader	230		QString glHeaderString;
225	// ===================================================================
226	QTextStream stream(&vertexSource);
227		231
228	if (gles) {	232		if (gles) {
229	if (core) {	233		if (core) {
230	stream << "#version 300 es\n\n";	234		glHeaderString += "#version 300 es\n\n";
231	}	235		}
232	stream << "precision highp float;\n";	236
		237		glHeaderString += "precision highp float;\n";
233	} else if (glsl_140) {	238		} else if (glsl_140) {
234	stream << "#version 140\n\n";	239		glHeaderString += "#version 140\n\n";
			anthonyfieroniUnsubmitted Done QString glHeaderString; if (gles) { if (core) { glHeaderString += "#version 300 es\n\n"; } glHeaderString += "precision highp float;\n"; } else if (glsl_140) { glHeaderString += "#version 140\n\n"; } streamVert << glHeaderString; anthonyfieroni: ``` QString glHeaderString; if (gles) { if (core) { glHeaderString += "#version 300…
235	}	240		}
236		241
237	stream << "uniform mat4 modelViewProjectionMatrix;\n";	242		QString glUniformString = "uniform sampler2D texUnit;\n"
238	stream << "uniform mat4 textureMatrix;\n";	243		"uniform float offset;\n"
239	stream << "uniform vec2 pixelSize;\n\n";	244		"uniform vec2 renderTextureSize;\n"
			fredrikUnsubmitted Done textureSize is also the name of a built-in function in GLSL, so I suggest changing the name to targetSize, renderTargetSize, framebufferSize or something similar. That also makes it clear that it is not the size of the texture being sampled. fredrik: textureSize is also the name of a built-in function in GLSL, so I suggest changing the name to…
240	stream << attribute << " vec4 vertex;\n\n";	245		"uniform vec2 halfpixel;\n";
241	stream << varying_out << " vec4 samplePos[" << std::ceil(size / 2.0) << "];\n";
242	stream << "\n";
243	stream << "void main(void)\n";
244	stream << "{\n";
245	stream << " vec4 center = vec4(textureMatrix * vertex).stst;\n";
246	stream << " vec4 ps = pixelSize.stst;\n\n";
247	for (int i = 0; i < offsets.size(); i++) {
248	stream << " samplePos[" << i << "] = center + ps * vec4("
249	<< offsets[i].x() << ", " << offsets[i].y() << ", "
250	<< offsets[i].z() << ", " << offsets[i].w() << ");\n";
251	}
252	stream << "\n";
253	stream << " gl_Position = modelViewProjectionMatrix * vertex;\n";
254	stream << "}\n";
255	stream.flush();
256		246
257	// Fragment shader
258	// ===================================================================
259	QTextStream stream2(&fragmentSource);
260
261	if (gles) {
262	if (core) {	247		if (core) {
263	stream2 << "#version 300 es\n\n";	248		glUniformString += "out vec4 fragColor;\n\n";
264	}
265	stream2 << "precision highp float;\n";
266	} else if (glsl_140) {
267	stream2 << "#version 140\n\n";
268	}	249		}
269		250
270	stream2 << "uniform sampler2D texUnit;\n";
271	stream2 << varying_in << " vec4 samplePos[" << std::ceil(size / 2.0) << "];\n\n";
272		251
273	for (int i = 0; i <= center; i++)	252		// Vertex shader
274	stream2 << "const float kernel" << i << " = " << kernel[i].g << ";\n";	253		// ===================================================================
			anthonyfieroniUnsubmitted Done QString glUniformString = "uniform sampler2D texUnit;\n" "uniform float offset;\n" "uniform vec2 textureSize;\n"; if (core) { glUniformString += "out vec4 fragColor;\n\n"; } streamFragDown << glUniformString; anthonyfieroni: ``` QString glUniformString = "uniform sampler2D texUnit;\n" "uniform…
275	stream2 << "\n";	254		QTextStream streamVert(&vertexSource);
		255
		256		streamVert << glHeaderString;
		257
		258		streamVert << "uniform mat4 modelViewProjectionMatrix;\n";
		259		streamVert << attribute << " vec4 vertex;\n\n";
		260		streamVert << "\n";
		261		streamVert << "void main(void)\n";
		262		streamVert << "{\n";
		263		streamVert << " gl_Position = modelViewProjectionMatrix * vertex;\n";
		264		streamVert << "}\n";
			anthonyfieroniUnsubmitted Done streamFragDown << glHeaderString; anthonyfieroni: ``` streamFragDown << glHeaderString; ```
		265
		266		streamVert.flush();
		267
		268		// Fragment shader (Dual Kawase Blur) - Downsample
		269		// ===================================================================
		270		QTextStream streamFragDown(&fragmentDownSource);
		271
		272		streamFragDown << glHeaderString << glUniformString;
		273
		274		streamFragDown << "void main(void)\n";
		275		streamFragDown << "{\n";
		276		streamFragDown << " vec2 uv = vec2(gl_FragCoord.xy / renderTextureSize);\n";
		277		streamFragDown << " \n";
		278		streamFragDown << " vec4 sum = " << texture2D << "(texUnit, uv) * 4.0;\n";
		279		streamFragDown << " sum += " << texture2D << "(texUnit, uv - halfpixel.xy * offset);\n";
		280		streamFragDown << " sum += " << texture2D << "(texUnit, uv + halfpixel.xy * offset);\n";
		281		streamFragDown << " sum += " << texture2D << "(texUnit, uv + vec2(halfpixel.x, -halfpixel.y) * offset);\n";
		282		streamFragDown << " sum += " << texture2D << "(texUnit, uv - vec2(halfpixel.x, -halfpixel.y) * offset);\n";
		283		streamFragDown << " \n";
		284		streamFragDown << " " << fragColor << " = sum / 8.0;\n";
		285		streamFragDown << "}\n";
		286
		287		streamFragDown.flush();
		288
		289		// Fragment shader (Dual Kawase Blur) - Upsample
		290		// ===================================================================
		291		QTextStream streamFragUp(&fragmentUpSource);
		292
		293		streamFragUp << glHeaderString << glUniformString;
		294
		295		streamFragUp << "void main(void)\n";
		296		streamFragUp << "{\n";
		297		streamFragUp << " vec2 uv = vec2(gl_FragCoord.xy / renderTextureSize);\n";
		298		streamFragUp << " \n";
		299		streamFragUp << " vec4 sum = " << texture2D << "(texUnit, uv + vec2(-halfpixel.x * 2.0, 0.0) * offset);\n";
		300		streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(-halfpixel.x, halfpixel.y) * offset) * 2.0;\n";
		301		streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(0.0, halfpixel.y * 2.0) * offset);\n";
		302		streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(halfpixel.x, halfpixel.y) * offset) * 2.0;\n";
		303		streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(halfpixel.x * 2.0, 0.0) * offset);\n";
		304		streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(halfpixel.x, -halfpixel.y) * offset) * 2.0;\n";
		305		streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(0.0, -halfpixel.y * 2.0) * offset);\n";
		306		streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(-halfpixel.x, -halfpixel.y) * offset) * 2.0;\n";
		307		streamFragUp << " \n";
		308		streamFragUp << " " << fragColor << " = sum / 12.0;\n";
		309		streamFragUp << "}\n";
		310
		311		streamFragUp.flush();
		312
		313		// Fragment shader - Copy texture
		314		// ===================================================================
		315		QTextStream streamFragCopy(&fragmentCopySource);
		316
		317		streamFragCopy << glHeaderString;
		318
		319		streamFragCopy << "uniform sampler2D texUnit;\n";
		320		streamFragCopy << "uniform vec2 renderTextureSize;\n";
		321		streamFragCopy << "uniform vec4 blurRect;\n";
276		322
			anthonyfieroniUnsubmitted Done streamFragUp << glHeaderString << glUniformString; anthonyfieroni: ``` streamFragUp << glHeaderString << glUniformString; ```
277	if (core)	323		if (core)
278	stream2 << "out vec4 fragColor;\n\n";	324		streamFragCopy << "out vec4 fragColor;\n\n";
279		325
280	stream2 << "void main(void)\n";	326		streamFragCopy << "void main(void)\n";
281	stream2 << "{\n";	327		streamFragCopy << "{\n";
282	stream2 << " vec4 sum = " << texture2D << "(texUnit, samplePos[0].st) * kernel0;\n";	328		streamFragCopy << " vec2 uv = vec2(gl_FragCoord.xy / renderTextureSize);\n";
283	for (int i = 1, j = -center + 1; i < size; i++, j++)	329		streamFragCopy << " " << fragColor << " = " << texture2D << "(texUnit, clamp(uv, blurRect.xy, blurRect.zw));\n";
284	stream2 << " sum = sum + " << texture2D << "(texUnit, samplePos[" << i / 2	330		streamFragCopy << "}\n";
285	<< ((i % 2) ? "].pq)" : "].st)") << " * kernel" << center - qAbs(j) << ";\n";	331
286	stream2 << " " << fragColor << " = sum;\n";	332		streamFragCopy.flush();
287	stream2 << "}\n";	333
288	stream2.flush();	334
289		335		m_shaderDownsample = ShaderManager::instance()->loadShaderFromCode(vertexSource, fragmentDownSource);
290	shader = ShaderManager::instance()->loadShaderFromCode(vertexSource, fragmentSource);	336		m_shaderUpsample = ShaderManager::instance()->loadShaderFromCode(vertexSource, fragmentUpSource);
291	if (shader->isValid()) {	337		m_shaderCopysample = ShaderManager::instance()->loadShaderFromCode(vertexSource, fragmentCopySource);
292	pixelSizeLocation = shader->uniformLocation("pixelSize");	338
293	textureMatrixLocation = shader->uniformLocation("textureMatrix");	339		bool areShadersValid = m_shaderDownsample->isValid() && m_shaderUpsample->isValid() && m_shaderCopysample->isValid();
294	mvpMatrixLocation = shader->uniformLocation("modelViewProjectionMatrix");	340		setIsValid(areShadersValid);
		341
		342		if (areShadersValid) {
		343		m_mvpMatrixLocationDownsample = m_shaderDownsample->uniformLocation("modelViewProjectionMatrix");
		344		m_offsetLocationDownsample = m_shaderDownsample->uniformLocation("offset");
		345		m_renderTextureSizeLocationDownsample = m_shaderDownsample->uniformLocation("renderTextureSize");
		346		m_halfpixelLocationDownsample = m_shaderDownsample->uniformLocation("halfpixel");
		347
		348		m_mvpMatrixLocationUpsample = m_shaderUpsample->uniformLocation("modelViewProjectionMatrix");
		349		m_offsetLocationUpsample = m_shaderUpsample->uniformLocation("offset");
		350		m_renderTextureSizeLocationUpsample = m_shaderUpsample->uniformLocation("renderTextureSize");
		351		m_halfpixelLocationUpsample = m_shaderUpsample->uniformLocation("halfpixel");
		352
		353		m_mvpMatrixLocationCopysample = m_shaderCopysample->uniformLocation("modelViewProjectionMatrix");
		354		m_renderTextureSizeLocationCopysample = m_shaderCopysample->uniformLocation("renderTextureSize");
		355		m_blurRectLocationCopysample = m_shaderCopysample->uniformLocation("blurRect");
295		356
296	QMatrix4x4 modelViewProjection;	357		QMatrix4x4 modelViewProjection;
297	const QSize screenSize = effects->virtualScreenSize();	358		const QSize screenSize = effects->virtualScreenSize();
298	modelViewProjection.ortho(0, screenSize.width(), screenSize.height(), 0, 0, 65535);	359		modelViewProjection.ortho(0, screenSize.width(), screenSize.height(), 0, 0, 65535);
299	ShaderManager::instance()->pushShader(shader);	360
			anthonyfieroniUnsubmitted Done streamFragCopy << glHeaderString << glUniformString; anthonyfieroni: ``` streamFragCopy << glHeaderString << glUniformString; ```
300	shader->setUniform(textureMatrixLocation, QMatrix4x4());	361		//Add default values to the uniforms of the shaders
301	shader->setUniform(mvpMatrixLocation, modelViewProjection);	362		ShaderManager::instance()->pushShader(m_shaderDownsample);
		363		m_shaderDownsample->setUniform(m_mvpMatrixLocationDownsample, modelViewProjection);
		364		m_shaderDownsample->setUniform(m_offsetLocationDownsample, float(1.0));
		365		m_shaderDownsample->setUniform(m_renderTextureSizeLocationDownsample, QVector2D(1.0, 1.0));
		366		m_shaderDownsample->setUniform(m_halfpixelLocationDownsample, QVector2D(1.0, 1.0));
		367		ShaderManager::instance()->popShader();
		368
		369		ShaderManager::instance()->pushShader(m_shaderUpsample);
		370		m_shaderUpsample->setUniform(m_mvpMatrixLocationUpsample, modelViewProjection);
		371		m_shaderUpsample->setUniform(m_offsetLocationUpsample, float(1.0));
		372		m_shaderUpsample->setUniform(m_renderTextureSizeLocationUpsample, QVector2D(1.0, 1.0));
		373		m_shaderUpsample->setUniform(m_halfpixelLocationUpsample, QVector2D(1.0, 1.0));
302	ShaderManager::instance()->popShader();	374		ShaderManager::instance()->popShader();
303	}
304		375
305	setIsValid(shader->isValid());	376		ShaderManager::instance()->pushShader(m_shaderCopysample);
		377		m_shaderCopysample->setUniform(m_mvpMatrixLocationCopysample, modelViewProjection);
		378		m_shaderCopysample->setUniform(m_renderTextureSizeLocationCopysample, QVector2D(1.0, 1.0));
		379		m_shaderCopysample->setUniform(m_blurRectLocationCopysample, QVector4D(1.0, 1.0, 1.0, 1.0));
		380		ShaderManager::instance()->popShader();
		381
		382		m_activeSampleType = -1;
		383		}
306	}	384		}