Differential D10281 Diff 26954 effects/blur/blurshader.cpp

Changeset View

Standalone View

effects/blur/blurshader.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Line(s)		66	{
68	m_shaderDownsample = nullptr;	68		m_shaderDownsample = nullptr;
69		69
70	delete m_shaderUpsample;	70		delete m_shaderUpsample;
71	m_shaderUpsample = nullptr;	71		m_shaderUpsample = nullptr;
72		72
73	delete m_shaderCopysample;	73		delete m_shaderCopysample;
74	m_shaderCopysample = nullptr;	74		m_shaderCopysample = nullptr;
75		75
		76		delete m_shaderNoisesample;
		77		m_shaderNoisesample = nullptr;
		78
76	setIsValid(false);	79		setIsValid(false);
77	}	80		}
78		81
79	void GLSLBlurShader::setModelViewProjectionMatrix(const QMatrix4x4 &matrix)	82		void GLSLBlurShader::setModelViewProjectionMatrix(const QMatrix4x4 &matrix)
80	{	83		{
81	if (!isValid())	84		if (!isValid())
82	return;	85		return;
83		86
Show All 16 Lines		87	switch (m_activeSampleType) {
100		103
101	case DownSampleType:	104		case DownSampleType:
102	if (matrix == m_matrixDownsample)	105		if (matrix == m_matrixDownsample)
103	return;	106		return;
104		107
105	m_matrixDownsample = matrix;	108		m_matrixDownsample = matrix;
106	m_shaderDownsample->setUniform(m_mvpMatrixLocationDownsample, matrix);	109		m_shaderDownsample->setUniform(m_mvpMatrixLocationDownsample, matrix);
107	break;	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;
108	}	119		}
109	}	120		}
110		121
111	void GLSLBlurShader::setOffset(float offset)	122		void GLSLBlurShader::setOffset(float offset)
112	{	123		{
113	if (!isValid())	124		if (!isValid())
114	return;	125		return;
115		126
116	switch (m_activeSampleType) {	127		switch (m_activeSampleType) {
117	case UpSampleType:	128		case UpSampleType:
118	if (offset == m_offsetUpsample)	129		if (offset == m_offsetUpsample)
119	return;	130		return;
120		131
121	m_offsetUpsample = offset;	132		m_offsetUpsample = offset;
122	m_shaderUpsample->setUniform(m_offsetLocationUpsample, offset);	133		m_shaderUpsample->setUniform(m_offsetLocationUpsample, offset);
123	break;	134		break;
124		135
125	case DownSampleType:	136		case DownSampleType:
126	if (offset == m_offsetDownsample)	137		if (offset == m_offsetDownsample)
127	return;	138		return;
128		139
129	m_offsetDownsample = offset;	140		m_offsetDownsample = offset;
130	m_shaderDownsample->setUniform(m_offsetLocationDownsample, offset);	141		m_shaderDownsample->setUniform(m_offsetLocationDownsample, offset);
131	break;	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;
132	}	151		}
133	}	152		}
134		153
135	void GLSLBlurShader::setTargetSize(QSize renderTextureSize)	154		void GLSLBlurShader::setTargetSize(QSize renderTextureSize, QSize noiseTextureSize)
136	{	155		{
137	if (!isValid())	156		if (!isValid())
138	return;	157		return;
139		158
140	QVector2D texSize = QVector2D(renderTextureSize.width(), renderTextureSize.height());	159		QVector2D texSize = QVector2D(renderTextureSize.width(), renderTextureSize.height());
141		160
142	switch (m_activeSampleType) {	161		switch (m_activeSampleType) {
143	case CopySampleType:	162		case CopySampleType:
144	if (renderTextureSize == m_renderTextureSizeCopysample)
145	return;
146
147	m_renderTextureSizeCopysample = renderTextureSize;
148	m_shaderCopysample->setUniform(m_renderTextureSizeLocationCopysample, texSize);	163		m_shaderCopysample->setUniform(m_renderTextureSizeLocationCopysample, texSize);
149	break;	164		break;
150		165
151	case UpSampleType:	166		case UpSampleType:
152	if (renderTextureSize == m_renderTextureSizeUpsample)
153	return;
154
155	m_renderTextureSizeUpsample = renderTextureSize;
156	m_shaderUpsample->setUniform(m_renderTextureSizeLocationUpsample, texSize);	167		m_shaderUpsample->setUniform(m_renderTextureSizeLocationUpsample, texSize);
157	m_shaderUpsample->setUniform(m_halfpixelLocationUpsample, QVector2D(0.5 / texSize.x(), 0.5 / texSize.y()));	168		m_shaderUpsample->setUniform(m_halfpixelLocationUpsample, QVector2D(0.5 / texSize.x(), 0.5 / texSize.y()));
158	break;	169		break;
159		170
160	case DownSampleType:	171		case DownSampleType:
161	if (renderTextureSize == m_renderTextureSizeDownsample)
162	return;
163
164	m_renderTextureSizeDownsample = renderTextureSize;
165	m_shaderDownsample->setUniform(m_renderTextureSizeLocationDownsample, texSize);	172		m_shaderDownsample->setUniform(m_renderTextureSizeLocationDownsample, texSize);
166	m_shaderDownsample->setUniform(m_halfpixelLocationDownsample, QVector2D(0.5 / texSize.x(), 0.5 / texSize.y()));	173		m_shaderDownsample->setUniform(m_halfpixelLocationDownsample, QVector2D(0.5 / texSize.x(), 0.5 / texSize.y()));
167	break;	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
		180		QVector2D noiseTexSize = QVector2D(noiseTextureSize.width(), noiseTextureSize.height());
		181
		182		if (noiseTexSize != m_noiseTextureSizeNoisesample) {
		183		m_noiseTextureSizeNoisesample = noiseTexSize;
		184		m_shaderNoisesample->setUniform(m_noiseTextureSizeLocationNoisesample, noiseTexSize);
		185		}
		186
		187		break;
168	}	188		}
169	}	189		}
170		190
		191		void GLSLBlurShader::setTexPosition(QPoint texPos)
		192		{
		193		m_shaderNoisesample->setUniform(m_texStartPosLocationNoisesample, QVector2D(-texPos.x(), texPos.y()));
		194		}
		195
171	void GLSLBlurShader::setBlurRect(QRect blurRect, QSize screenSize)	196		void GLSLBlurShader::setBlurRect(QRect blurRect, QSize screenSize)
172	{	197		{
173	if (!isValid() \|\| blurRect == m_blurRectCopysample)	198		if (!isValid() \|\| blurRect == m_blurRectCopysample)
174	return;	199		return;
175		200
176	m_blurRectCopysample = blurRect;	201		m_blurRectCopysample = blurRect;
177		202
178	QVector4D rect = QVector4D(	203		QVector4D rect = QVector4D(
179	blurRect.bottomLeft().x() / float(screenSize.width()),	204		blurRect.bottomLeft().x() / float(screenSize.width()),
180	1.0 - blurRect.bottomLeft().y() / float(screenSize.height()),	205		1.0 - blurRect.bottomLeft().y() / float(screenSize.height()),
181	blurRect.topRight().x() / float(screenSize.width()),	206		blurRect.topRight().x() / float(screenSize.width()),
182	1.0 - blurRect.topRight().y() / float(screenSize.height())	207		1.0 - blurRect.topRight().y() / float(screenSize.height())
183	);	208		);
184		209
185	m_shaderCopysample->setUniform(m_blurRectLocationCopysample, rect);	210		m_shaderCopysample->setUniform(m_blurRectLocationCopysample, rect);
186	}	211		}
187		212
188	void GLSLBlurShader::bind(SampleType sampleType)	213		void GLSLBlurShader::bind(SampleType sampleType)
			fredrikUnsubmitted Done This only needs to be done once after the shader has been linked. fredrik: This only needs to be done once after the shader has been linked.
189	{	214		{
190	if (!isValid())	215		if (!isValid())
191	return;	216		return;
192		217
193	switch (sampleType) {	218		switch (sampleType) {
194	case CopySampleType:	219		case CopySampleType:
195	ShaderManager::instance()->pushShader(m_shaderCopysample);	220		ShaderManager::instance()->pushShader(m_shaderCopysample);
196	break;	221		break;
197		222
198	case UpSampleType:	223		case UpSampleType:
199	ShaderManager::instance()->pushShader(m_shaderUpsample);	224		ShaderManager::instance()->pushShader(m_shaderUpsample);
200	break;	225		break;
201		226
202	case DownSampleType:	227		case DownSampleType:
203	ShaderManager::instance()->pushShader(m_shaderDownsample);	228		ShaderManager::instance()->pushShader(m_shaderDownsample);
204	break;	229		break;
		230
		231		case NoiseSampleType:
		232		ShaderManager::instance()->pushShader(m_shaderNoisesample);
		233		break;
205	}	234		}
206		235
207	m_activeSampleType = sampleType;	236		m_activeSampleType = sampleType;
208	}	237		}
209		238
210	void GLSLBlurShader::unbind()	239		void GLSLBlurShader::unbind()
211	{	240		{
212	ShaderManager::instance()->popShader();	241		ShaderManager::instance()->popShader();
213	}	242		}
214		243
215	void GLSLBlurShader::init()	244		void GLSLBlurShader::init()
216	{	245		{
217	const bool gles = GLPlatform::instance()->isGLES();	246		const bool gles = GLPlatform::instance()->isGLES();
218	const bool glsl_140 = !gles && GLPlatform::instance()->glslVersion() >= kVersionNumber(1, 40);	247		const bool glsl_140 = !gles && GLPlatform::instance()->glslVersion() >= kVersionNumber(1, 40);
219	const bool core = glsl_140 \|\| (gles && GLPlatform::instance()->glslVersion() >= kVersionNumber(3, 0));	248		const bool core = glsl_140 \|\| (gles && GLPlatform::instance()->glslVersion() >= kVersionNumber(3, 0));
220		249
221	QByteArray vertexSource;	250		QByteArray vertexSource;
222	QByteArray fragmentDownSource;	251		QByteArray fragmentDownSource;
223	QByteArray fragmentUpSource;	252		QByteArray fragmentUpSource;
224	QByteArray fragmentCopySource;	253		QByteArray fragmentCopySource;
		254		QByteArray fragmentNoiseSource;
225		255
226	const QByteArray attribute = core ? "in" : "attribute";	256		const QByteArray attribute = core ? "in" : "attribute";
227	const QByteArray texture2D = core ? "texture" : "texture2D";	257		const QByteArray texture2D = core ? "texture" : "texture2D";
228	const QByteArray fragColor = core ? "fragColor" : "gl_FragColor";	258		const QByteArray fragColor = core ? "fragColor" : "gl_FragColor";
229		259
230	QString glHeaderString;	260		QString glHeaderString;
231		261
232	if (gles) {	262		if (gles) {
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Line(s)
326	streamFragCopy << "void main(void)\n";	356		streamFragCopy << "void main(void)\n";
327	streamFragCopy << "{\n";	357		streamFragCopy << "{\n";
328	streamFragCopy << " vec2 uv = vec2(gl_FragCoord.xy / renderTextureSize);\n";	358		streamFragCopy << " vec2 uv = vec2(gl_FragCoord.xy / renderTextureSize);\n";
329	streamFragCopy << " " << fragColor << " = " << texture2D << "(texUnit, clamp(uv, blurRect.xy, blurRect.zw));\n";	359		streamFragCopy << " " << fragColor << " = " << texture2D << "(texUnit, clamp(uv, blurRect.xy, blurRect.zw));\n";
330	streamFragCopy << "}\n";	360		streamFragCopy << "}\n";
331		361
332	streamFragCopy.flush();	362		streamFragCopy.flush();
333		363
		364		// Fragment shader - Noise texture
		365		// ===================================================================
		366		QTextStream streamFragNoise(&fragmentNoiseSource);
		367
		368		streamFragNoise << glHeaderString << glUniformString;
		369
		370		streamFragNoise << "uniform sampler2D noiseTexUnit;\n";
		371		streamFragNoise << "uniform vec2 noiseTextureSize;\n";
		372		streamFragNoise << "uniform vec2 texStartPos;\n";
		373
		374		// Upsampling + Noise
		375		streamFragNoise << "void main(void)\n";
		376		streamFragNoise << "{\n";
		377		streamFragNoise << " vec2 uv = vec2(gl_FragCoord.xy / renderTextureSize);\n";
		378		streamFragNoise << " vec2 uvNoise = vec2((texStartPos.xy + gl_FragCoord.xy) / noiseTextureSize);\n";
		379		streamFragNoise << " \n";
		380		streamFragNoise << " vec4 sum = " << texture2D << "(texUnit, uv + vec2(-halfpixel.x * 2.0, 0.0) * offset);\n";
			fredrikUnsubmitted Done Always adding the noise value will make the pattern invisible when blurring a white area. Could this shader also do the final upscaling, so the two operations are combined? fredrik: Always adding the noise value will make the pattern invisible when blurring a white area.
			anemethAuthorUnsubmitted Done Fixed invisible problem. Combining upscaling and noise would add too much complication. It's better and easier to maintain by keeping them separate. anemeth: Fixed invisible problem. Combining upscaling and noise would add too much complication. It's…
			fredrikUnsubmitted Done Fixed invisible problem. Subtracting reverses the problem though, making the effect invisible over black backgrounds. I would subtract 0.5 from the noise value before adding it instead, so the range becomes [-0.5..+0.5] instead of [0...1]. Combining upscaling and noise would add too much complication. It's better and easier to maintain by keeping them separate. Doing both in one pass is usually faster though, because you only rasterize half as many pixels. Isn't combining the passes a matter of copying the code from the main function in the upscaling shader, and adding the noise value after dividing the sum by 12? The blur effect would just need to switch from the upscale shader to the noise shader before doing the final pass. fredrik: > Fixed invisible problem. Subtracting reverses the problem though, making the effect…
		381		streamFragNoise << " sum += " << texture2D << "(texUnit, uv + vec2(-halfpixel.x, halfpixel.y) * offset) * 2.0;\n";
		382		streamFragNoise << " sum += " << texture2D << "(texUnit, uv + vec2(0.0, halfpixel.y * 2.0) * offset);\n";
		383		streamFragNoise << " sum += " << texture2D << "(texUnit, uv + vec2(halfpixel.x, halfpixel.y) * offset) * 2.0;\n";
		384		streamFragNoise << " sum += " << texture2D << "(texUnit, uv + vec2(halfpixel.x * 2.0, 0.0) * offset);\n";
		385		streamFragNoise << " sum += " << texture2D << "(texUnit, uv + vec2(halfpixel.x, -halfpixel.y) * offset) * 2.0;\n";
		386		streamFragNoise << " sum += " << texture2D << "(texUnit, uv + vec2(0.0, -halfpixel.y * 2.0) * offset);\n";
		387		streamFragNoise << " sum += " << texture2D << "(texUnit, uv + vec2(-halfpixel.x, -halfpixel.y) * offset) * 2.0;\n";
		388		streamFragNoise << " \n";
		389		streamFragNoise << " " << fragColor << " = abs(sum / 12.0 - vec4(" << texture2D << "(noiseTexUnit, uvNoise).rrr, 0));\n";
			fredrikUnsubmitted Done This still subtracts the noise value. See the first part of my comment above. fredrik: This still subtracts the noise value. See the first part of my comment above.
			anemethAuthorUnsubmitted Done Yes, it substrats (darkens) the noise, but this time I added an abs() function to it. If the pixel color value is too low then it adds the noise to it (brightens). See table below for some examples for noise value 5 what happens to the pixel after the abs(): Before \| After ---------------- 100 95 (substracted normally) 10 5 (substracted normally) 8 3 (substracted normally) 5 0 (substracted normally) 4 1 (4 - 5 = -1 ---> abs(-1) = 1) 2 3 (3 - 5 = -3 ---> abs(-3) = 3) 0 5 (0 - 5 = -5 ---> abs(-5) = 5) anemeth: Yes, it substrats (darkens) the noise, but this time I added an abs() function to it. If the…
			fredrikUnsubmitted Done Right, I missed the abs(). The downside though is that the stronger the noise, the more the brightness of the image is reduced. If you are concerned about the cost of an additional subtraction, you can avoid that by changing the texture format to GL_R8_SNORM. That's a GL 3.1 feature though, so it would need a fallback path. fredrik: Right, I missed the abs(). The downside though is that the stronger the noise, the more the…
		390		streamFragNoise << "}\n";
		391
		392		streamFragNoise.flush();
		393
334		394
335	m_shaderDownsample = ShaderManager::instance()->loadShaderFromCode(vertexSource, fragmentDownSource);	395		m_shaderDownsample = ShaderManager::instance()->loadShaderFromCode(vertexSource, fragmentDownSource);
336	m_shaderUpsample = ShaderManager::instance()->loadShaderFromCode(vertexSource, fragmentUpSource);	396		m_shaderUpsample = ShaderManager::instance()->loadShaderFromCode(vertexSource, fragmentUpSource);
337	m_shaderCopysample = ShaderManager::instance()->loadShaderFromCode(vertexSource, fragmentCopySource);	397		m_shaderCopysample = ShaderManager::instance()->loadShaderFromCode(vertexSource, fragmentCopySource);
		398		m_shaderNoisesample = ShaderManager::instance()->loadShaderFromCode(vertexSource, fragmentNoiseSource);
338		399
339	bool areShadersValid = m_shaderDownsample->isValid() && m_shaderUpsample->isValid() && m_shaderCopysample->isValid();	400		bool areShadersValid = m_shaderDownsample->isValid() &&
		401		m_shaderUpsample->isValid() &&
		402		m_shaderCopysample->isValid() &&
		403		m_shaderNoisesample->isValid();
340	setIsValid(areShadersValid);	404		setIsValid(areShadersValid);
341		405
342	if (areShadersValid) {	406		if (areShadersValid) {
343	m_mvpMatrixLocationDownsample = m_shaderDownsample->uniformLocation("modelViewProjectionMatrix");	407		m_mvpMatrixLocationDownsample = m_shaderDownsample->uniformLocation("modelViewProjectionMatrix");
344	m_offsetLocationDownsample = m_shaderDownsample->uniformLocation("offset");	408		m_offsetLocationDownsample = m_shaderDownsample->uniformLocation("offset");
345	m_renderTextureSizeLocationDownsample = m_shaderDownsample->uniformLocation("renderTextureSize");	409		m_renderTextureSizeLocationDownsample = m_shaderDownsample->uniformLocation("renderTextureSize");
346	m_halfpixelLocationDownsample = m_shaderDownsample->uniformLocation("halfpixel");	410		m_halfpixelLocationDownsample = m_shaderDownsample->uniformLocation("halfpixel");
347		411
348	m_mvpMatrixLocationUpsample = m_shaderUpsample->uniformLocation("modelViewProjectionMatrix");	412		m_mvpMatrixLocationUpsample = m_shaderUpsample->uniformLocation("modelViewProjectionMatrix");
349	m_offsetLocationUpsample = m_shaderUpsample->uniformLocation("offset");	413		m_offsetLocationUpsample = m_shaderUpsample->uniformLocation("offset");
350	m_renderTextureSizeLocationUpsample = m_shaderUpsample->uniformLocation("renderTextureSize");	414		m_renderTextureSizeLocationUpsample = m_shaderUpsample->uniformLocation("renderTextureSize");
351	m_halfpixelLocationUpsample = m_shaderUpsample->uniformLocation("halfpixel");	415		m_halfpixelLocationUpsample = m_shaderUpsample->uniformLocation("halfpixel");
352		416
353	m_mvpMatrixLocationCopysample = m_shaderCopysample->uniformLocation("modelViewProjectionMatrix");	417		m_mvpMatrixLocationCopysample = m_shaderCopysample->uniformLocation("modelViewProjectionMatrix");
354	m_renderTextureSizeLocationCopysample = m_shaderCopysample->uniformLocation("renderTextureSize");	418		m_renderTextureSizeLocationCopysample = m_shaderCopysample->uniformLocation("renderTextureSize");
355	m_blurRectLocationCopysample = m_shaderCopysample->uniformLocation("blurRect");	419		m_blurRectLocationCopysample = m_shaderCopysample->uniformLocation("blurRect");
356		420
		421		m_mvpMatrixLocationNoisesample = m_shaderNoisesample->uniformLocation("modelViewProjectionMatrix");
		422		m_offsetLocationNoisesample = m_shaderNoisesample->uniformLocation("offset");
		423		m_renderTextureSizeLocationNoisesample = m_shaderNoisesample->uniformLocation("renderTextureSize");
		424		m_noiseTextureSizeLocationNoisesample = m_shaderNoisesample->uniformLocation("noiseTextureSize");
		425		m_texStartPosLocationNoisesample = m_shaderNoisesample->uniformLocation("texStartPos");
		426		m_halfpixelLocationNoisesample = m_shaderNoisesample->uniformLocation("halfpixel");
		427
357	QMatrix4x4 modelViewProjection;	428		QMatrix4x4 modelViewProjection;
358	const QSize screenSize = effects->virtualScreenSize();	429		const QSize screenSize = effects->virtualScreenSize();
359	modelViewProjection.ortho(0, screenSize.width(), screenSize.height(), 0, 0, 65535);	430		modelViewProjection.ortho(0, screenSize.width(), screenSize.height(), 0, 0, 65535);
360		431
361	//Add default values to the uniforms of the shaders	432		//Add default values to the uniforms of the shaders
362	ShaderManager::instance()->pushShader(m_shaderDownsample);	433		ShaderManager::instance()->pushShader(m_shaderDownsample);
363	m_shaderDownsample->setUniform(m_mvpMatrixLocationDownsample, modelViewProjection);	434		m_shaderDownsample->setUniform(m_mvpMatrixLocationDownsample, modelViewProjection);
364	m_shaderDownsample->setUniform(m_offsetLocationDownsample, float(1.0));	435		m_shaderDownsample->setUniform(m_offsetLocationDownsample, float(1.0));
Show All 9 Lines
374	ShaderManager::instance()->popShader();	445		ShaderManager::instance()->popShader();
375		446
376	ShaderManager::instance()->pushShader(m_shaderCopysample);	447		ShaderManager::instance()->pushShader(m_shaderCopysample);
377	m_shaderCopysample->setUniform(m_mvpMatrixLocationCopysample, modelViewProjection);	448		m_shaderCopysample->setUniform(m_mvpMatrixLocationCopysample, modelViewProjection);
378	m_shaderCopysample->setUniform(m_renderTextureSizeLocationCopysample, QVector2D(1.0, 1.0));	449		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));	450		m_shaderCopysample->setUniform(m_blurRectLocationCopysample, QVector4D(1.0, 1.0, 1.0, 1.0));
380	ShaderManager::instance()->popShader();	451		ShaderManager::instance()->popShader();
381		452
		453		ShaderManager::instance()->pushShader(m_shaderNoisesample);
		454		m_shaderNoisesample->setUniform(m_mvpMatrixLocationNoisesample, modelViewProjection);
		455		m_shaderNoisesample->setUniform(m_offsetLocationNoisesample, float(1.0));
		456		m_shaderNoisesample->setUniform(m_renderTextureSizeLocationNoisesample, QVector2D(1.0, 1.0));
		457		m_shaderNoisesample->setUniform(m_noiseTextureSizeLocationNoisesample, QVector2D(1.0, 1.0));
		458		m_shaderNoisesample->setUniform(m_texStartPosLocationNoisesample, QVector2D(1.0, 1.0));
		459		m_shaderNoisesample->setUniform(m_halfpixelLocationNoisesample, QVector2D(1.0, 1.0));
		460
		461		glUniform1i(m_shaderNoisesample->uniformLocation("texUnit"), 0);
		462		glUniform1i(m_shaderNoisesample->uniformLocation("noiseTexUnit"), 1);
		463
		464		ShaderManager::instance()->popShader();
		465
382	m_activeSampleType = -1;	466		m_activeSampleType = -1;
383	}	467		}
384	}	468		}