Differential D9848 Diff 25949 effects/blur/blurshader.cpp

Changeset View

Standalone View

View Options

effects/blur/blurshader.cpp

PropertyOld ValueNew Value
File Mode100644100755
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​
32using namespace KWin; 34​using namespace KWin;
33 35​
34 36​
35BlurShader::BlurShader() 37​BlurShader::BlurShader()
36 : mRadius(0), mValid(false) 38​ : mValid(false)
37{ 39​{
38} 40​}
39 41​
40BlurShader::~BlurShader() 42​BlurShader::~BlurShader()
41{ 43​{
42} 44​}
43 45​
44BlurShader *BlurShader::create() 46​BlurShader *BlurShader::create()
45{ 47​{
46 return new GLSLBlurShader(); 48​ return new GLSLBlurShader();
47} 49​}
48 50​
49void 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​
60void 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 =…
65float 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​
71QList<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​
113GLSLBlurShader::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 ​
118GLSLBlurShader::~GLSLBlurShader() ​
119{ ​
120 reset(); ​
121} 133​}
122 134​
123void 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`
131void 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​
145void 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​
153void 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​
161void 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​
169void GLSLBlurShader::unbind() 207​ m_activeSampleType = sampleType;
170{ ​
171 ShaderManager::instance()->popShader(); ​
172} 208​}
173 209​
174int 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​
190void 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​}