Differential D13110 Diff 35124 effects/blur/blurshader.cpp

Changeset View

Standalone View

effects/blur/blurshader.cpp

Show All 15 Lines
16	* 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
17	* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,	17		* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18	* Boston, MA 02110-1301, USA.	18		* Boston, MA 02110-1301, USA.
19	*/	19		*/
20		20
21	#include "blurshader.h"	21		#include "blurshader.h"
22		22
23	#include <kwineffects.h>	23		#include <kwineffects.h>
24	#include "kwinglutils.h"
25	#include <kwinglplatform.h>	24		#include <kwinglplatform.h>
		25		#include <kwinglutils.h>
26		26
27	#include <QByteArray>	27		#include <QByteArray>
28	#include <QMatrix4x4>
29	#include <QTextStream>	28		#include <QTextStream>
30	#include <QVector2D>
31		29
32	#include <cmath>	30		namespace KWin
33
34	using namespace KWin;
35
36
37	BlurShader::BlurShader()
38	: mValid(false)
39	{
40	}
41
42	BlurShader::~BlurShader()
43	{
44	}
45
46	BlurShader *BlurShader::create()
47	{
48	return new GLSLBlurShader();
49	}
50
51	// ----------------------------------------------------------------------------
52
53
54
55	GLSLBlurShader::GLSLBlurShader()
56	{
57	init();
58	}
59
60	GLSLBlurShader::~GLSLBlurShader()
61	{
62	reset();
63	}
64
65	void GLSLBlurShader::reset()
66	{
67	delete m_shaderDownsample;
68	m_shaderDownsample = nullptr;
69
70	delete m_shaderUpsample;
71	m_shaderUpsample = nullptr;
72
73	delete m_shaderCopysample;
74	m_shaderCopysample = nullptr;
75
76	delete m_shaderNoisesample;
77	m_shaderNoisesample = nullptr;
78
79	setIsValid(false);
80	}
81
82	void GLSLBlurShader::setModelViewProjectionMatrix(const QMatrix4x4 &matrix)
83	{
84	if (!isValid())
85	return;
86
87	switch (m_activeSampleType) {
88	case CopySampleType:
89	if (matrix == m_matrixCopysample)
90	return;
91
92	m_matrixCopysample = matrix;
93	m_shaderCopysample->setUniform(m_mvpMatrixLocationCopysample, matrix);
94	break;
95
96	case UpSampleType:
97	if (matrix == m_matrixUpsample)
98	return;
99
100	m_matrixUpsample = matrix;
101	m_shaderUpsample->setUniform(m_mvpMatrixLocationUpsample, matrix);
102	break;
103
104	case DownSampleType:
105	if (matrix == m_matrixDownsample)
106	return;
107
108	m_matrixDownsample = matrix;
109	m_shaderDownsample->setUniform(m_mvpMatrixLocationDownsample, matrix);
110	break;
111
112	case NoiseSampleType:
113	if (matrix == m_matrixNoisesample)
114	return;
115
116	m_matrixNoisesample = matrix;
117	m_shaderNoisesample->setUniform(m_mvpMatrixLocationNoisesample, matrix);
118	break;
119	}
120	}
121
122	void GLSLBlurShader::setOffset(float offset)
123	{
124	if (!isValid())
125	return;
126
127	switch (m_activeSampleType) {
128	case UpSampleType:
129	if (offset == m_offsetUpsample)
130	return;
131
132	m_offsetUpsample = offset;
133	m_shaderUpsample->setUniform(m_offsetLocationUpsample, offset);
134	break;
135
136	case DownSampleType:
137	if (offset == m_offsetDownsample)
138	return;
139
140	m_offsetDownsample = offset;
141	m_shaderDownsample->setUniform(m_offsetLocationDownsample, offset);
142	break;
143
144	case NoiseSampleType:
145	if (offset == m_offsetNoisesample)
146	return;
147
148	m_offsetNoisesample = offset;
149	m_shaderNoisesample->setUniform(m_offsetLocationNoisesample, offset);
150	break;
151	}
152	}
153
154	void GLSLBlurShader::setTargetTextureSize(QSize renderTextureSize)
155	{
156	if (!isValid())
157	return;
158
159	QVector2D texSize = QVector2D(renderTextureSize.width(), renderTextureSize.height());
160
161	switch (m_activeSampleType) {
162	case CopySampleType:
163	m_shaderCopysample->setUniform(m_renderTextureSizeLocationCopysample, texSize);
164	break;
165
166	case UpSampleType:
167	m_shaderUpsample->setUniform(m_renderTextureSizeLocationUpsample, texSize);
168	m_shaderUpsample->setUniform(m_halfpixelLocationUpsample, QVector2D(0.5 / texSize.x(), 0.5 / texSize.y()));
169	break;
170
171	case DownSampleType:
172	m_shaderDownsample->setUniform(m_renderTextureSizeLocationDownsample, texSize);
173	m_shaderDownsample->setUniform(m_halfpixelLocationDownsample, QVector2D(0.5 / texSize.x(), 0.5 / texSize.y()));
174	break;
175
176	case NoiseSampleType:
177	m_shaderNoisesample->setUniform(m_renderTextureSizeLocationNoisesample, texSize);
178	m_shaderNoisesample->setUniform(m_halfpixelLocationNoisesample, QVector2D(0.5 / texSize.x(), 0.5 / texSize.y()));
179	break;
180	}
181	}
182
183	void GLSLBlurShader::setNoiseTextureSize(QSize noiseTextureSize)
184	{
185	QVector2D noiseTexSize = QVector2D(noiseTextureSize.width(), noiseTextureSize.height());
186
187	if (noiseTexSize != m_noiseTextureSizeNoisesample) {
188	m_noiseTextureSizeNoisesample = noiseTexSize;
189	m_shaderNoisesample->setUniform(m_noiseTextureSizeLocationNoisesample, noiseTexSize);
190	}
191	}
192
193	void GLSLBlurShader::setTexturePosition(QPoint texPos)
194	{
195	m_shaderNoisesample->setUniform(m_texStartPosLocationNoisesample, QVector2D(-texPos.x(), texPos.y()));
196	}
197
198	void GLSLBlurShader::setBlurRect(QRect blurRect, QSize screenSize)
199	{
200	if (!isValid() \|\| blurRect == m_blurRectCopysample)
201	return;
202
203	m_blurRectCopysample = blurRect;
204
205	QVector4D rect = QVector4D(
206	blurRect.bottomLeft().x() / float(screenSize.width()),
207	1.0 - blurRect.bottomLeft().y() / float(screenSize.height()),
208	blurRect.topRight().x() / float(screenSize.width()),
209	1.0 - blurRect.topRight().y() / float(screenSize.height())
210	);
211
212	m_shaderCopysample->setUniform(m_blurRectLocationCopysample, rect);
213	}
214
215	void GLSLBlurShader::bind(SampleType sampleType)
216	{
217	if (!isValid())
218	return;
219
220	switch (sampleType) {
221	case CopySampleType:
222	ShaderManager::instance()->pushShader(m_shaderCopysample);
223	break;
224
225	case UpSampleType:
226	ShaderManager::instance()->pushShader(m_shaderUpsample);
227	break;
228
229	case DownSampleType:
230	ShaderManager::instance()->pushShader(m_shaderDownsample);
231	break;
232
233	case NoiseSampleType:
234	ShaderManager::instance()->pushShader(m_shaderNoisesample);
235	break;
236	}
237
238	m_activeSampleType = sampleType;
239	}
240
241	void GLSLBlurShader::unbind()
242	{	31		{
243	ShaderManager::instance()->popShader();
244	}
245		32
246	void GLSLBlurShader::init()	33		BlurShader::BlurShader(QObject *parent)
		34		: QObject(parent)
247	{	35		{
248	const bool gles = GLPlatform::instance()->isGLES();	36		const bool gles = GLPlatform::instance()->isGLES();
249	const bool glsl_140 = !gles && GLPlatform::instance()->glslVersion() >= kVersionNumber(1, 40);	37		const bool glsl_140 = !gles && GLPlatform::instance()->glslVersion() >= kVersionNumber(1, 40);
250	const bool core = glsl_140 \|\| (gles && GLPlatform::instance()->glslVersion() >= kVersionNumber(3, 0));	38		const bool core = glsl_140 \|\| (gles && GLPlatform::instance()->glslVersion() >= kVersionNumber(3, 0));
251		39
252	QByteArray vertexSource;	40		QByteArray vertexSource;
253	QByteArray fragmentDownSource;	41		QByteArray fragmentDownSource;
254	QByteArray fragmentUpSource;	42		QByteArray fragmentUpSource;
Show All 20 Lines		62	QString glUniformString = "uniform sampler2D texUnit;\n"
275	"uniform float offset;\n"	63		"uniform float offset;\n"
276	"uniform vec2 renderTextureSize;\n"	64		"uniform vec2 renderTextureSize;\n"
277	"uniform vec2 halfpixel;\n";	65		"uniform vec2 halfpixel;\n";
278		66
279	if (core) {	67		if (core) {
280	glUniformString += "out vec4 fragColor;\n\n";	68		glUniformString += "out vec4 fragColor;\n\n";
281	}	69		}
282		70
283
284	// Vertex shader	71		// Vertex shader
285	// ===================================================================
286	QTextStream streamVert(&vertexSource);	72		QTextStream streamVert(&vertexSource);
287		73
288	streamVert << glHeaderString;	74		streamVert << glHeaderString;
289		75
290	streamVert << "uniform mat4 modelViewProjectionMatrix;\n";	76		streamVert << "uniform mat4 modelViewProjectionMatrix;\n";
291	streamVert << attribute << " vec4 vertex;\n\n";	77		streamVert << attribute << " vec4 vertex;\n\n";
292	streamVert << "\n";	78		streamVert << "\n";
293	streamVert << "void main(void)\n";	79		streamVert << "void main(void)\n";
294	streamVert << "{\n";	80		streamVert << "{\n";
295	streamVert << " gl_Position = modelViewProjectionMatrix * vertex;\n";	81		streamVert << " gl_Position = modelViewProjectionMatrix * vertex;\n";
296	streamVert << "}\n";	82		streamVert << "}\n";
297		83
298	streamVert.flush();	84		streamVert.flush();
299		85
300	// Fragment shader (Dual Kawase Blur) - Downsample	86		// Fragment shader (Dual Kawase Blur) - Downsample
301	// ===================================================================
302	QTextStream streamFragDown(&fragmentDownSource);	87		QTextStream streamFragDown(&fragmentDownSource);
303		88
304	streamFragDown << glHeaderString << glUniformString;	89		streamFragDown << glHeaderString << glUniformString;
305		90
306	streamFragDown << "void main(void)\n";	91		streamFragDown << "void main(void)\n";
307	streamFragDown << "{\n";	92		streamFragDown << "{\n";
308	streamFragDown << " vec2 uv = vec2(gl_FragCoord.xy / renderTextureSize);\n";	93		streamFragDown << " vec2 uv = vec2(gl_FragCoord.xy / renderTextureSize);\n";
309	streamFragDown << " \n";	94		streamFragDown << " \n";
310	streamFragDown << " vec4 sum = " << texture2D << "(texUnit, uv) * 4.0;\n";	95		streamFragDown << " vec4 sum = " << texture2D << "(texUnit, uv) * 4.0;\n";
311	streamFragDown << " sum += " << texture2D << "(texUnit, uv - halfpixel.xy * offset);\n";	96		streamFragDown << " sum += " << texture2D << "(texUnit, uv - halfpixel.xy * offset);\n";
312	streamFragDown << " sum += " << texture2D << "(texUnit, uv + halfpixel.xy * offset);\n";	97		streamFragDown << " sum += " << texture2D << "(texUnit, uv + halfpixel.xy * offset);\n";
313	streamFragDown << " sum += " << texture2D << "(texUnit, uv + vec2(halfpixel.x, -halfpixel.y) * offset);\n";	98		streamFragDown << " sum += " << texture2D << "(texUnit, uv + vec2(halfpixel.x, -halfpixel.y) * offset);\n";
314	streamFragDown << " sum += " << texture2D << "(texUnit, uv - vec2(halfpixel.x, -halfpixel.y) * offset);\n";	99		streamFragDown << " sum += " << texture2D << "(texUnit, uv - vec2(halfpixel.x, -halfpixel.y) * offset);\n";
315	streamFragDown << " \n";	100		streamFragDown << " \n";
316	streamFragDown << " " << fragColor << " = sum / 8.0;\n";	101		streamFragDown << " " << fragColor << " = sum / 8.0;\n";
317	streamFragDown << "}\n";	102		streamFragDown << "}\n";
318		103
319	streamFragDown.flush();	104		streamFragDown.flush();
320		105
321	// Fragment shader (Dual Kawase Blur) - Upsample	106		// Fragment shader (Dual Kawase Blur) - Upsample
322	// ===================================================================
323	QTextStream streamFragUp(&fragmentUpSource);	107		QTextStream streamFragUp(&fragmentUpSource);
324		108
325	streamFragUp << glHeaderString << glUniformString;	109		streamFragUp << glHeaderString << glUniformString;
326		110
327	streamFragUp << "void main(void)\n";	111		streamFragUp << "void main(void)\n";
328	streamFragUp << "{\n";	112		streamFragUp << "{\n";
329	streamFragUp << " vec2 uv = vec2(gl_FragCoord.xy / renderTextureSize);\n";	113		streamFragUp << " vec2 uv = vec2(gl_FragCoord.xy / renderTextureSize);\n";
330	streamFragUp << " \n";	114		streamFragUp << " \n";
331	streamFragUp << " vec4 sum = " << texture2D << "(texUnit, uv + vec2(-halfpixel.x * 2.0, 0.0) * offset);\n";	115		streamFragUp << " vec4 sum = " << texture2D << "(texUnit, uv + vec2(-halfpixel.x * 2.0, 0.0) * offset);\n";
332	streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(-halfpixel.x, halfpixel.y) * offset) * 2.0;\n";	116		streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(-halfpixel.x, halfpixel.y) * offset) * 2.0;\n";
333	streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(0.0, halfpixel.y * 2.0) * offset);\n";	117		streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(0.0, halfpixel.y * 2.0) * offset);\n";
334	streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(halfpixel.x, halfpixel.y) * offset) * 2.0;\n";	118		streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(halfpixel.x, halfpixel.y) * offset) * 2.0;\n";
335	streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(halfpixel.x * 2.0, 0.0) * offset);\n";	119		streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(halfpixel.x * 2.0, 0.0) * offset);\n";
336	streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(halfpixel.x, -halfpixel.y) * offset) * 2.0;\n";	120		streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(halfpixel.x, -halfpixel.y) * offset) * 2.0;\n";
337	streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(0.0, -halfpixel.y * 2.0) * offset);\n";	121		streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(0.0, -halfpixel.y * 2.0) * offset);\n";
338	streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(-halfpixel.x, -halfpixel.y) * offset) * 2.0;\n";	122		streamFragUp << " sum += " << texture2D << "(texUnit, uv + vec2(-halfpixel.x, -halfpixel.y) * offset) * 2.0;\n";
339	streamFragUp << " \n";	123		streamFragUp << " \n";
340	streamFragUp << " " << fragColor << " = sum / 12.0;\n";	124		streamFragUp << " " << fragColor << " = sum / 12.0;\n";
341	streamFragUp << "}\n";	125		streamFragUp << "}\n";
342		126
343	streamFragUp.flush();	127		streamFragUp.flush();
344		128
345	// Fragment shader - Copy texture	129		// Fragment shader - Copy texture
346	// ===================================================================
347	QTextStream streamFragCopy(&fragmentCopySource);	130		QTextStream streamFragCopy(&fragmentCopySource);
348		131
349	streamFragCopy << glHeaderString;	132		streamFragCopy << glHeaderString;
350		133
351	streamFragCopy << "uniform sampler2D texUnit;\n";	134		streamFragCopy << "uniform sampler2D texUnit;\n";
352	streamFragCopy << "uniform vec2 renderTextureSize;\n";	135		streamFragCopy << "uniform vec2 renderTextureSize;\n";
353	streamFragCopy << "uniform vec4 blurRect;\n";	136		streamFragCopy << "uniform vec4 blurRect;\n";
354		137
355	if (core)	138		if (core) {
356	streamFragCopy << "out vec4 fragColor;\n\n";	139		streamFragCopy << "out vec4 fragColor;\n\n";
		140		}
357		141
358	streamFragCopy << "void main(void)\n";	142		streamFragCopy << "void main(void)\n";
359	streamFragCopy << "{\n";	143		streamFragCopy << "{\n";
360	streamFragCopy << " vec2 uv = vec2(gl_FragCoord.xy / renderTextureSize);\n";	144		streamFragCopy << " vec2 uv = vec2(gl_FragCoord.xy / renderTextureSize);\n";
361	streamFragCopy << " " << fragColor << " = " << texture2D << "(texUnit, clamp(uv, blurRect.xy, blurRect.zw));\n";	145		streamFragCopy << " " << fragColor << " = " << texture2D << "(texUnit, clamp(uv, blurRect.xy, blurRect.zw));\n";
362	streamFragCopy << "}\n";	146		streamFragCopy << "}\n";
363		147
364	streamFragCopy.flush();	148		streamFragCopy.flush();
365		149
366	// Fragment shader - Noise texture	150		// Fragment shader - Noise texture
367	// ===================================================================
368	QTextStream streamFragNoise(&fragmentNoiseSource);	151		QTextStream streamFragNoise(&fragmentNoiseSource);
369		152
370	streamFragNoise << glHeaderString << glUniformString;	153		streamFragNoise << glHeaderString << glUniformString;
371		154
372	streamFragNoise << "uniform sampler2D noiseTexUnit;\n";	155		streamFragNoise << "uniform sampler2D noiseTexUnit;\n";
373	streamFragNoise << "uniform vec2 noiseTextureSize;\n";	156		streamFragNoise << "uniform vec2 noiseTextureSize;\n";
374	streamFragNoise << "uniform vec2 texStartPos;\n";	157		streamFragNoise << "uniform vec2 texStartPos;\n";
375		158
Show All 12 Lines
388	streamFragNoise << " sum += " << texture2D << "(texUnit, uv + vec2(0.0, -halfpixel.y * 2.0) * offset);\n";	171		streamFragNoise << " sum += " << texture2D << "(texUnit, uv + vec2(0.0, -halfpixel.y * 2.0) * offset);\n";
389	streamFragNoise << " sum += " << texture2D << "(texUnit, uv + vec2(-halfpixel.x, -halfpixel.y) * offset) * 2.0;\n";	172		streamFragNoise << " sum += " << texture2D << "(texUnit, uv + vec2(-halfpixel.x, -halfpixel.y) * offset) * 2.0;\n";
390	streamFragNoise << " \n";	173		streamFragNoise << " \n";
391	streamFragNoise << " " << fragColor << " = sum / 12.0 - (vec4(0.5, 0.5, 0.5, 0) - vec4(" << texture2D << "(noiseTexUnit, uvNoise).rrr, 0));\n";	174		streamFragNoise << " " << fragColor << " = sum / 12.0 - (vec4(0.5, 0.5, 0.5, 0) - vec4(" << texture2D << "(noiseTexUnit, uvNoise).rrr, 0));\n";
392	streamFragNoise << "}\n";	175		streamFragNoise << "}\n";
393		176
394	streamFragNoise.flush();	177		streamFragNoise.flush();
395		178
		179		m_shaderDownsample.reset(ShaderManager::instance()->loadShaderFromCode(vertexSource, fragmentDownSource));
		180		m_shaderUpsample.reset(ShaderManager::instance()->loadShaderFromCode(vertexSource, fragmentUpSource));
		181		m_shaderCopysample.reset(ShaderManager::instance()->loadShaderFromCode(vertexSource, fragmentCopySource));
		182		m_shaderNoisesample.reset(ShaderManager::instance()->loadShaderFromCode(vertexSource, fragmentNoiseSource));
396		183
397	m_shaderDownsample = ShaderManager::instance()->loadShaderFromCode(vertexSource, fragmentDownSource);	184		m_valid = m_shaderDownsample->isValid() &&
398	m_shaderUpsample = ShaderManager::instance()->loadShaderFromCode(vertexSource, fragmentUpSource);
399	m_shaderCopysample = ShaderManager::instance()->loadShaderFromCode(vertexSource, fragmentCopySource);
400	m_shaderNoisesample = ShaderManager::instance()->loadShaderFromCode(vertexSource, fragmentNoiseSource);
401
402	bool areShadersValid = m_shaderDownsample->isValid() &&
403	m_shaderUpsample->isValid() &&	185		m_shaderUpsample->isValid() &&
404	m_shaderCopysample->isValid() &&	186		m_shaderCopysample->isValid() &&
405	m_shaderNoisesample->isValid();	187		m_shaderNoisesample->isValid();
406	setIsValid(areShadersValid);
407		188
408	if (areShadersValid) {	189		if (m_valid) {
409	m_mvpMatrixLocationDownsample = m_shaderDownsample->uniformLocation("modelViewProjectionMatrix");	190		m_mvpMatrixLocationDownsample = m_shaderDownsample->uniformLocation("modelViewProjectionMatrix");
410	m_offsetLocationDownsample = m_shaderDownsample->uniformLocation("offset");	191		m_offsetLocationDownsample = m_shaderDownsample->uniformLocation("offset");
411	m_renderTextureSizeLocationDownsample = m_shaderDownsample->uniformLocation("renderTextureSize");	192		m_renderTextureSizeLocationDownsample = m_shaderDownsample->uniformLocation("renderTextureSize");
412	m_halfpixelLocationDownsample = m_shaderDownsample->uniformLocation("halfpixel");	193		m_halfpixelLocationDownsample = m_shaderDownsample->uniformLocation("halfpixel");
413		194
414	m_mvpMatrixLocationUpsample = m_shaderUpsample->uniformLocation("modelViewProjectionMatrix");	195		m_mvpMatrixLocationUpsample = m_shaderUpsample->uniformLocation("modelViewProjectionMatrix");
415	m_offsetLocationUpsample = m_shaderUpsample->uniformLocation("offset");	196		m_offsetLocationUpsample = m_shaderUpsample->uniformLocation("offset");
416	m_renderTextureSizeLocationUpsample = m_shaderUpsample->uniformLocation("renderTextureSize");	197		m_renderTextureSizeLocationUpsample = m_shaderUpsample->uniformLocation("renderTextureSize");
Show All 10 Lines
427	m_texStartPosLocationNoisesample = m_shaderNoisesample->uniformLocation("texStartPos");	208		m_texStartPosLocationNoisesample = m_shaderNoisesample->uniformLocation("texStartPos");
428	m_halfpixelLocationNoisesample = m_shaderNoisesample->uniformLocation("halfpixel");	209		m_halfpixelLocationNoisesample = m_shaderNoisesample->uniformLocation("halfpixel");
429		210
430	QMatrix4x4 modelViewProjection;	211		QMatrix4x4 modelViewProjection;
431	const QSize screenSize = effects->virtualScreenSize();	212		const QSize screenSize = effects->virtualScreenSize();
432	modelViewProjection.ortho(0, screenSize.width(), screenSize.height(), 0, 0, 65535);	213		modelViewProjection.ortho(0, screenSize.width(), screenSize.height(), 0, 0, 65535);
433		214
434	//Add default values to the uniforms of the shaders	215		//Add default values to the uniforms of the shaders
435	ShaderManager::instance()->pushShader(m_shaderDownsample);	216		ShaderManager::instance()->pushShader(m_shaderDownsample.data());
436	m_shaderDownsample->setUniform(m_mvpMatrixLocationDownsample, modelViewProjection);	217		m_shaderDownsample->setUniform(m_mvpMatrixLocationDownsample, modelViewProjection);
437	m_shaderDownsample->setUniform(m_offsetLocationDownsample, float(1.0));	218		m_shaderDownsample->setUniform(m_offsetLocationDownsample, float(1.0));
438	m_shaderDownsample->setUniform(m_renderTextureSizeLocationDownsample, QVector2D(1.0, 1.0));	219		m_shaderDownsample->setUniform(m_renderTextureSizeLocationDownsample, QVector2D(1.0, 1.0));
439	m_shaderDownsample->setUniform(m_halfpixelLocationDownsample, QVector2D(1.0, 1.0));	220		m_shaderDownsample->setUniform(m_halfpixelLocationDownsample, QVector2D(1.0, 1.0));
440	ShaderManager::instance()->popShader();	221		ShaderManager::instance()->popShader();
441		222
442	ShaderManager::instance()->pushShader(m_shaderUpsample);	223		ShaderManager::instance()->pushShader(m_shaderUpsample.data());
443	m_shaderUpsample->setUniform(m_mvpMatrixLocationUpsample, modelViewProjection);	224		m_shaderUpsample->setUniform(m_mvpMatrixLocationUpsample, modelViewProjection);
444	m_shaderUpsample->setUniform(m_offsetLocationUpsample, float(1.0));	225		m_shaderUpsample->setUniform(m_offsetLocationUpsample, float(1.0));
445	m_shaderUpsample->setUniform(m_renderTextureSizeLocationUpsample, QVector2D(1.0, 1.0));	226		m_shaderUpsample->setUniform(m_renderTextureSizeLocationUpsample, QVector2D(1.0, 1.0));
446	m_shaderUpsample->setUniform(m_halfpixelLocationUpsample, QVector2D(1.0, 1.0));	227		m_shaderUpsample->setUniform(m_halfpixelLocationUpsample, QVector2D(1.0, 1.0));
447	ShaderManager::instance()->popShader();	228		ShaderManager::instance()->popShader();
448		229
449	ShaderManager::instance()->pushShader(m_shaderCopysample);	230		ShaderManager::instance()->pushShader(m_shaderCopysample.data());
450	m_shaderCopysample->setUniform(m_mvpMatrixLocationCopysample, modelViewProjection);	231		m_shaderCopysample->setUniform(m_mvpMatrixLocationCopysample, modelViewProjection);
451	m_shaderCopysample->setUniform(m_renderTextureSizeLocationCopysample, QVector2D(1.0, 1.0));	232		m_shaderCopysample->setUniform(m_renderTextureSizeLocationCopysample, QVector2D(1.0, 1.0));
452	m_shaderCopysample->setUniform(m_blurRectLocationCopysample, QVector4D(1.0, 1.0, 1.0, 1.0));	233		m_shaderCopysample->setUniform(m_blurRectLocationCopysample, QVector4D(1.0, 1.0, 1.0, 1.0));
453	ShaderManager::instance()->popShader();	234		ShaderManager::instance()->popShader();
454		235
455	ShaderManager::instance()->pushShader(m_shaderNoisesample);	236		ShaderManager::instance()->pushShader(m_shaderNoisesample.data());
456	m_shaderNoisesample->setUniform(m_mvpMatrixLocationNoisesample, modelViewProjection);	237		m_shaderNoisesample->setUniform(m_mvpMatrixLocationNoisesample, modelViewProjection);
457	m_shaderNoisesample->setUniform(m_offsetLocationNoisesample, float(1.0));	238		m_shaderNoisesample->setUniform(m_offsetLocationNoisesample, float(1.0));
458	m_shaderNoisesample->setUniform(m_renderTextureSizeLocationNoisesample, QVector2D(1.0, 1.0));	239		m_shaderNoisesample->setUniform(m_renderTextureSizeLocationNoisesample, QVector2D(1.0, 1.0));
459	m_shaderNoisesample->setUniform(m_noiseTextureSizeLocationNoisesample, QVector2D(1.0, 1.0));	240		m_shaderNoisesample->setUniform(m_noiseTextureSizeLocationNoisesample, QVector2D(1.0, 1.0));
460	m_shaderNoisesample->setUniform(m_texStartPosLocationNoisesample, QVector2D(1.0, 1.0));	241		m_shaderNoisesample->setUniform(m_texStartPosLocationNoisesample, QVector2D(1.0, 1.0));
461	m_shaderNoisesample->setUniform(m_halfpixelLocationNoisesample, QVector2D(1.0, 1.0));	242		m_shaderNoisesample->setUniform(m_halfpixelLocationNoisesample, QVector2D(1.0, 1.0));
462		243
463	glUniform1i(m_shaderNoisesample->uniformLocation("texUnit"), 0);	244		glUniform1i(m_shaderNoisesample->uniformLocation("texUnit"), 0);
464	glUniform1i(m_shaderNoisesample->uniformLocation("noiseTexUnit"), 1);	245		glUniform1i(m_shaderNoisesample->uniformLocation("noiseTexUnit"), 1);
465		246
466	ShaderManager::instance()->popShader();	247		ShaderManager::instance()->popShader();
		248		}
		249		}
		250
		251		BlurShader::~BlurShader()
		252		{
		253		}
		254
		255		void BlurShader::setModelViewProjectionMatrix(const QMatrix4x4 &matrix)
		256		{
		257		if (!isValid()) {
		258		return;
		259		}
		260
		261		switch (m_activeSampleType) {
		262		case CopySampleType:
		263		if (matrix == m_matrixCopysample) {
		264		return;
		265		}
		266
		267		m_matrixCopysample = matrix;
		268		m_shaderCopysample->setUniform(m_mvpMatrixLocationCopysample, matrix);
		269		break;
467		270
468	m_activeSampleType = -1;	271		case UpSampleType:
		272		if (matrix == m_matrixUpsample) {
		273		return;
		274		}
469		275
470	m_offsetDownsample = 0.0;	276		m_matrixUpsample = matrix;
471	m_matrixDownsample = QMatrix4x4();	277		m_shaderUpsample->setUniform(m_mvpMatrixLocationUpsample, matrix);
		278		break;
472		279
473	m_offsetUpsample = 0.0;	280		case DownSampleType:
474	m_matrixUpsample = QMatrix4x4();	281		if (matrix == m_matrixDownsample) {
		282		return;
		283		}
475		284
476	m_matrixCopysample = QMatrix4x4();	285		m_matrixDownsample = matrix;
477	m_blurRectCopysample = QRect();	286		m_shaderDownsample->setUniform(m_mvpMatrixLocationDownsample, matrix);
		287		break;
478		288
479	m_offsetNoisesample = 0.0;	289		case NoiseSampleType:
480	m_noiseTextureSizeNoisesample = QVector2D();	290		if (matrix == m_matrixNoisesample) {
481	m_matrixNoisesample = QMatrix4x4();	291		return;
		292		}
		293
		294		m_matrixNoisesample = matrix;
		295		m_shaderNoisesample->setUniform(m_mvpMatrixLocationNoisesample, matrix);
		296		break;
		297
		298		default:
		299		Q_UNREACHABLE();
		300		break;
		301		}
		302		}
		303
		304		void BlurShader::setOffset(float offset)
		305		{
		306		if (!isValid()) {
		307		return;
		308		}
		309
		310		switch (m_activeSampleType) {
		311		case UpSampleType:
		312		if (offset == m_offsetUpsample) {
		313		return;
		314		}
		315
		316		m_offsetUpsample = offset;
		317		m_shaderUpsample->setUniform(m_offsetLocationUpsample, offset);
		318		break;
		319
		320		case DownSampleType:
		321		if (offset == m_offsetDownsample) {
		322		return;
		323		}
		324
		325		m_offsetDownsample = offset;
		326		m_shaderDownsample->setUniform(m_offsetLocationDownsample, offset);
		327		break;
		328
		329		case NoiseSampleType:
		330		if (offset == m_offsetNoisesample) {
		331		return;
		332		}
		333
		334		m_offsetNoisesample = offset;
		335		m_shaderNoisesample->setUniform(m_offsetLocationNoisesample, offset);
		336		break;
		337
		338		default:
		339		Q_UNREACHABLE();
		340		break;
482	}	341		}
483	}	342		}
		343
		344		void BlurShader::setTargetTextureSize(const QSize &renderTextureSize)
		345		{
		346		if (!isValid()) {
		347		return;
		348		}
		349
		350		const QVector2D texSize(renderTextureSize.width(), renderTextureSize.height());
		351
		352		switch (m_activeSampleType) {
		353		case CopySampleType:
		354		m_shaderCopysample->setUniform(m_renderTextureSizeLocationCopysample, texSize);
		355		break;
		356
		357		case UpSampleType:
		358		m_shaderUpsample->setUniform(m_renderTextureSizeLocationUpsample, texSize);
		359		m_shaderUpsample->setUniform(m_halfpixelLocationUpsample, QVector2D(0.5 / texSize.x(), 0.5 / texSize.y()));
		360		break;
		361
		362		case DownSampleType:
		363		m_shaderDownsample->setUniform(m_renderTextureSizeLocationDownsample, texSize);
		364		m_shaderDownsample->setUniform(m_halfpixelLocationDownsample, QVector2D(0.5 / texSize.x(), 0.5 / texSize.y()));
		365		break;
		366
		367		case NoiseSampleType:
		368		m_shaderNoisesample->setUniform(m_renderTextureSizeLocationNoisesample, texSize);
		369		m_shaderNoisesample->setUniform(m_halfpixelLocationNoisesample, QVector2D(0.5 / texSize.x(), 0.5 / texSize.y()));
		370		break;
		371
		372		default:
		373		Q_UNREACHABLE();
		374		break;
		375		}
		376		}
		377
		378		void BlurShader::setNoiseTextureSize(const QSize &noiseTextureSize)
		379		{
		380		const QVector2D noiseTexSize(noiseTextureSize.width(), noiseTextureSize.height());
		381
		382		if (noiseTexSize != m_noiseTextureSizeNoisesample) {
		383		m_noiseTextureSizeNoisesample = noiseTexSize;
		384		m_shaderNoisesample->setUniform(m_noiseTextureSizeLocationNoisesample, noiseTexSize);
		385		}
		386		}
		387
		388		void BlurShader::setTexturePosition(const QPoint &texPos)
		389		{
		390		m_shaderNoisesample->setUniform(m_texStartPosLocationNoisesample, QVector2D(-texPos.x(), texPos.y()));
		391		}
		392
		393		void BlurShader::setBlurRect(const QRect &blurRect, const QSize &screenSize)
		394		{
		395		if (!isValid()) {
		396		return;
		397		}
		398
		399		const QVector4D rect(
		400		blurRect.left() / float(screenSize.width()),
		401		1.0 - blurRect.bottom() / float(screenSize.height()),
		402		blurRect.right() / float(screenSize.width()),
		403		1.0 - blurRect.top() / float(screenSize.height())
		404		);
		405
		406		m_shaderCopysample->setUniform(m_blurRectLocationCopysample, rect);
		407		}
		408
		409		void BlurShader::bind(SampleType sampleType)
		410		{
		411		if (!isValid()) {
		412		return;
		413		}
		414
		415		switch (sampleType) {
		416		case CopySampleType:
		417		ShaderManager::instance()->pushShader(m_shaderCopysample.data());
		418		break;
		419
		420		case UpSampleType:
		421		ShaderManager::instance()->pushShader(m_shaderUpsample.data());
		422		break;
		423
		424		case DownSampleType:
		425		ShaderManager::instance()->pushShader(m_shaderDownsample.data());
		426		break;
		427
		428		case NoiseSampleType:
		429		ShaderManager::instance()->pushShader(m_shaderNoisesample.data());
		430		break;
		431
		432		default:
		433		Q_UNREACHABLE();
		434		break;
		435		}
		436
		437		m_activeSampleType = sampleType;
		438		}
		439
		440		void BlurShader::unbind()
		441		{
		442		ShaderManager::instance()->popShader();
		443		}
		444
		445		} // namespace KWin