1 /*
2 * Copyright 2015 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "GrCircleBlurFragmentProcessor.h"
9
10 #if SK_SUPPORT_GPU
11
12 #include "GrContext.h"
13 #include "GrResourceProvider.h"
14 #include "glsl/GrGLSLFragmentProcessor.h"
15 #include "glsl/GrGLSLFragmentShaderBuilder.h"
16 #include "glsl/GrGLSLProgramDataManager.h"
17 #include "glsl/GrGLSLUniformHandler.h"
18
19 #include "SkFixed.h"
20
21 class GrCircleBlurFragmentProcessor::GLSLProcessor : public GrGLSLFragmentProcessor {
22 public:
23 void emitCode(EmitArgs&) override;
24
25 protected:
26 void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
27
28 private:
29 GrGLSLProgramDataManager::UniformHandle fDataUniform;
30
31 typedef GrGLSLFragmentProcessor INHERITED;
32 };
33
emitCode(EmitArgs & args)34 void GrCircleBlurFragmentProcessor::GLSLProcessor::emitCode(EmitArgs& args) {
35 const char *dataName;
36
37 // The data is formatted as:
38 // x,y - the center of the circle
39 // z - inner radius that should map to 0th entry in the texture.
40 // w - the inverse of the distance over which the texture is stretched.
41 fDataUniform = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
42 kVec4f_GrSLType,
43 kDefault_GrSLPrecision,
44 "data",
45 &dataName);
46
47 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
48
49 if (args.fInputColor) {
50 fragBuilder->codeAppendf("vec4 src=%s;", args.fInputColor);
51 } else {
52 fragBuilder->codeAppendf("vec4 src=vec4(1);");
53 }
54
55 // We just want to compute "(length(vec) - %s.z + 0.5) * %s.w" but need to rearrange
56 // for precision.
57 fragBuilder->codeAppendf("vec2 vec = vec2( (sk_FragCoord.x - %s.x) * %s.w, "
58 "(sk_FragCoord.y - %s.y) * %s.w );",
59 dataName, dataName, dataName, dataName);
60 fragBuilder->codeAppendf("float dist = length(vec) + (0.5 - %s.z) * %s.w;",
61 dataName, dataName);
62
63 fragBuilder->codeAppendf("float intensity = ");
64 fragBuilder->appendTextureLookup(args.fTexSamplers[0], "vec2(dist, 0.5)");
65 fragBuilder->codeAppend(".a;");
66
67 fragBuilder->codeAppendf("%s = src * intensity;\n", args.fOutputColor );
68 }
69
onSetData(const GrGLSLProgramDataManager & pdman,const GrProcessor & proc)70 void GrCircleBlurFragmentProcessor::GLSLProcessor::onSetData(const GrGLSLProgramDataManager& pdman,
71 const GrProcessor& proc) {
72 const GrCircleBlurFragmentProcessor& cbfp = proc.cast<GrCircleBlurFragmentProcessor>();
73 const SkRect& circle = cbfp.fCircle;
74
75 // The data is formatted as:
76 // x,y - the center of the circle
77 // z - inner radius that should map to 0th entry in the texture.
78 // w - the inverse of the distance over which the profile texture is stretched.
79 pdman.set4f(fDataUniform, circle.centerX(), circle.centerY(), cbfp.fSolidRadius,
80 1.f / cbfp.fTextureRadius);
81 }
82
83 ///////////////////////////////////////////////////////////////////////////////
84
GrCircleBlurFragmentProcessor(GrResourceProvider * resourceProvider,const SkRect & circle,float textureRadius,float solidRadius,sk_sp<GrTextureProxy> blurProfile)85 GrCircleBlurFragmentProcessor::GrCircleBlurFragmentProcessor(GrResourceProvider* resourceProvider,
86 const SkRect& circle,
87 float textureRadius,
88 float solidRadius,
89 sk_sp<GrTextureProxy> blurProfile)
90 : INHERITED(kCompatibleWithCoverageAsAlpha_OptimizationFlag)
91 , fCircle(circle)
92 , fSolidRadius(solidRadius)
93 , fTextureRadius(textureRadius)
94 , fBlurProfileSampler(resourceProvider, std::move(blurProfile),
95 GrSamplerParams::kBilerp_FilterMode) {
96 this->initClassID<GrCircleBlurFragmentProcessor>();
97 this->addTextureSampler(&fBlurProfileSampler);
98 }
99
onCreateGLSLInstance() const100 GrGLSLFragmentProcessor* GrCircleBlurFragmentProcessor::onCreateGLSLInstance() const {
101 return new GLSLProcessor;
102 }
103
onGetGLSLProcessorKey(const GrShaderCaps & caps,GrProcessorKeyBuilder * b) const104 void GrCircleBlurFragmentProcessor::onGetGLSLProcessorKey(const GrShaderCaps& caps,
105 GrProcessorKeyBuilder* b) const {
106 // The code for this processor is always the same so there is nothing to add to the key.
107 return;
108 }
109
110 // Computes an unnormalized half kernel (right side). Returns the summation of all the half kernel
111 // values.
make_unnormalized_half_kernel(float * halfKernel,int halfKernelSize,float sigma)112 static float make_unnormalized_half_kernel(float* halfKernel, int halfKernelSize, float sigma) {
113 const float invSigma = 1.f / sigma;
114 const float b = -0.5f * invSigma * invSigma;
115 float tot = 0.0f;
116 // Compute half kernel values at half pixel steps out from the center.
117 float t = 0.5f;
118 for (int i = 0; i < halfKernelSize; ++i) {
119 float value = expf(t * t * b);
120 tot += value;
121 halfKernel[i] = value;
122 t += 1.f;
123 }
124 return tot;
125 }
126
127 // Create a Gaussian half-kernel (right side) and a summed area table given a sigma and number of
128 // discrete steps. The half kernel is normalized to sum to 0.5.
make_half_kernel_and_summed_table(float * halfKernel,float * summedHalfKernel,int halfKernelSize,float sigma)129 static void make_half_kernel_and_summed_table(float* halfKernel, float* summedHalfKernel,
130 int halfKernelSize, float sigma) {
131 // The half kernel should sum to 0.5 not 1.0.
132 const float tot = 2.f * make_unnormalized_half_kernel(halfKernel, halfKernelSize, sigma);
133 float sum = 0.f;
134 for (int i = 0; i < halfKernelSize; ++i) {
135 halfKernel[i] /= tot;
136 sum += halfKernel[i];
137 summedHalfKernel[i] = sum;
138 }
139 }
140
141 // Applies the 1D half kernel vertically at points along the x axis to a circle centered at the
142 // origin with radius circleR.
apply_kernel_in_y(float * results,int numSteps,float firstX,float circleR,int halfKernelSize,const float * summedHalfKernelTable)143 void apply_kernel_in_y(float* results, int numSteps, float firstX, float circleR,
144 int halfKernelSize, const float* summedHalfKernelTable) {
145 float x = firstX;
146 for (int i = 0; i < numSteps; ++i, x += 1.f) {
147 if (x < -circleR || x > circleR) {
148 results[i] = 0;
149 continue;
150 }
151 float y = sqrtf(circleR * circleR - x * x);
152 // In the column at x we exit the circle at +y and -y
153 // The summed table entry j is actually reflects an offset of j + 0.5.
154 y -= 0.5f;
155 int yInt = SkScalarFloorToInt(y);
156 SkASSERT(yInt >= -1);
157 if (y < 0) {
158 results[i] = (y + 0.5f) * summedHalfKernelTable[0];
159 } else if (yInt >= halfKernelSize - 1) {
160 results[i] = 0.5f;
161 } else {
162 float yFrac = y - yInt;
163 results[i] = (1.f - yFrac) * summedHalfKernelTable[yInt] +
164 yFrac * summedHalfKernelTable[yInt + 1];
165 }
166 }
167 }
168
169 // Apply a Gaussian at point (evalX, 0) to a circle centered at the origin with radius circleR.
170 // This relies on having a half kernel computed for the Gaussian and a table of applications of
171 // the half kernel in y to columns at (evalX - halfKernel, evalX - halfKernel + 1, ..., evalX +
172 // halfKernel) passed in as yKernelEvaluations.
eval_at(float evalX,float circleR,const float * halfKernel,int halfKernelSize,const float * yKernelEvaluations)173 static uint8_t eval_at(float evalX, float circleR, const float* halfKernel, int halfKernelSize,
174 const float* yKernelEvaluations) {
175 float acc = 0;
176
177 float x = evalX - halfKernelSize;
178 for (int i = 0; i < halfKernelSize; ++i, x += 1.f) {
179 if (x < -circleR || x > circleR) {
180 continue;
181 }
182 float verticalEval = yKernelEvaluations[i];
183 acc += verticalEval * halfKernel[halfKernelSize - i - 1];
184 }
185 for (int i = 0; i < halfKernelSize; ++i, x += 1.f) {
186 if (x < -circleR || x > circleR) {
187 continue;
188 }
189 float verticalEval = yKernelEvaluations[i + halfKernelSize];
190 acc += verticalEval * halfKernel[i];
191 }
192 // Since we applied a half kernel in y we multiply acc by 2 (the circle is symmetric about the
193 // x axis).
194 return SkUnitScalarClampToByte(2.f * acc);
195 }
196
197 // This function creates a profile of a blurred circle. It does this by computing a kernel for
198 // half the Gaussian and a matching summed area table. The summed area table is used to compute
199 // an array of vertical applications of the half kernel to the circle along the x axis. The table
200 // of y evaluations has 2 * k + n entries where k is the size of the half kernel and n is the size
201 // of the profile being computed. Then for each of the n profile entries we walk out k steps in each
202 // horizontal direction multiplying the corresponding y evaluation by the half kernel entry and
203 // sum these values to compute the profile entry.
create_circle_profile(float sigma,float circleR,int profileTextureWidth)204 static uint8_t* create_circle_profile(float sigma, float circleR, int profileTextureWidth) {
205 const int numSteps = profileTextureWidth;
206 uint8_t* weights = new uint8_t[numSteps];
207
208 // The full kernel is 6 sigmas wide.
209 int halfKernelSize = SkScalarCeilToInt(6.0f*sigma);
210 // round up to next multiple of 2 and then divide by 2
211 halfKernelSize = ((halfKernelSize + 1) & ~1) >> 1;
212
213 // Number of x steps at which to apply kernel in y to cover all the profile samples in x.
214 int numYSteps = numSteps + 2 * halfKernelSize;
215
216 SkAutoTArray<float> bulkAlloc(halfKernelSize + halfKernelSize + numYSteps);
217 float* halfKernel = bulkAlloc.get();
218 float* summedKernel = bulkAlloc.get() + halfKernelSize;
219 float* yEvals = bulkAlloc.get() + 2 * halfKernelSize;
220 make_half_kernel_and_summed_table(halfKernel, summedKernel, halfKernelSize, sigma);
221
222 float firstX = -halfKernelSize + 0.5f;
223 apply_kernel_in_y(yEvals, numYSteps, firstX, circleR, halfKernelSize, summedKernel);
224
225 for (int i = 0; i < numSteps - 1; ++i) {
226 float evalX = i + 0.5f;
227 weights[i] = eval_at(evalX, circleR, halfKernel, halfKernelSize, yEvals + i);
228 }
229 // Ensure the tail of the Gaussian goes to zero.
230 weights[numSteps - 1] = 0;
231 return weights;
232 }
233
create_half_plane_profile(int profileWidth)234 static uint8_t* create_half_plane_profile(int profileWidth) {
235 SkASSERT(!(profileWidth & 0x1));
236 // The full kernel is 6 sigmas wide.
237 float sigma = profileWidth / 6.f;
238 int halfKernelSize = profileWidth / 2;
239
240 SkAutoTArray<float> halfKernel(halfKernelSize);
241 uint8_t* profile = new uint8_t[profileWidth];
242
243 // The half kernel should sum to 0.5.
244 const float tot = 2.f * make_unnormalized_half_kernel(halfKernel.get(), halfKernelSize, sigma);
245 float sum = 0.f;
246 // Populate the profile from the right edge to the middle.
247 for (int i = 0; i < halfKernelSize; ++i) {
248 halfKernel[halfKernelSize - i - 1] /= tot;
249 sum += halfKernel[halfKernelSize - i - 1];
250 profile[profileWidth - i - 1] = SkUnitScalarClampToByte(sum);
251 }
252 // Populate the profile from the middle to the left edge (by flipping the half kernel and
253 // continuing the summation).
254 for (int i = 0; i < halfKernelSize; ++i) {
255 sum += halfKernel[i];
256 profile[halfKernelSize - i - 1] = SkUnitScalarClampToByte(sum);
257 }
258 // Ensure tail goes to 0.
259 profile[profileWidth - 1] = 0;
260 return profile;
261 }
262
create_profile_texture(GrResourceProvider * resourceProvider,const SkRect & circle,float sigma,float * solidRadius,float * textureRadius)263 static sk_sp<GrTextureProxy> create_profile_texture(GrResourceProvider* resourceProvider,
264 const SkRect& circle,
265 float sigma,
266 float* solidRadius, float* textureRadius) {
267 float circleR = circle.width() / 2.0f;
268 // Profile textures are cached by the ratio of sigma to circle radius and by the size of the
269 // profile texture (binned by powers of 2).
270 SkScalar sigmaToCircleRRatio = sigma / circleR;
271 // When sigma is really small this becomes a equivalent to convolving a Gaussian with a half-
272 // plane. Similarly, in the extreme high ratio cases circle becomes a point WRT to the Guassian
273 // and the profile texture is a just a Gaussian evaluation. However, we haven't yet implemented
274 // this latter optimization.
275 sigmaToCircleRRatio = SkTMin(sigmaToCircleRRatio, 8.f);
276 SkFixed sigmaToCircleRRatioFixed;
277 static const SkScalar kHalfPlaneThreshold = 0.1f;
278 bool useHalfPlaneApprox = false;
279 if (sigmaToCircleRRatio <= kHalfPlaneThreshold) {
280 useHalfPlaneApprox = true;
281 sigmaToCircleRRatioFixed = 0;
282 *solidRadius = circleR - 3 * sigma;
283 *textureRadius = 6 * sigma;
284 } else {
285 // Convert to fixed point for the key.
286 sigmaToCircleRRatioFixed = SkScalarToFixed(sigmaToCircleRRatio);
287 // We shave off some bits to reduce the number of unique entries. We could probably shave
288 // off more than we do.
289 sigmaToCircleRRatioFixed &= ~0xff;
290 sigmaToCircleRRatio = SkFixedToScalar(sigmaToCircleRRatioFixed);
291 sigma = circleR * sigmaToCircleRRatio;
292 *solidRadius = 0;
293 *textureRadius = circleR + 3 * sigma;
294 }
295
296 static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
297 GrUniqueKey key;
298 GrUniqueKey::Builder builder(&key, kDomain, 1);
299 builder[0] = sigmaToCircleRRatioFixed;
300 builder.finish();
301
302 sk_sp<GrTextureProxy> blurProfile = resourceProvider->findProxyByUniqueKey(key);
303 if (!blurProfile) {
304 static constexpr int kProfileTextureWidth = 512;
305 GrSurfaceDesc texDesc;
306 texDesc.fWidth = kProfileTextureWidth;
307 texDesc.fHeight = 1;
308 texDesc.fConfig = kAlpha_8_GrPixelConfig;
309
310 std::unique_ptr<uint8_t[]> profile(nullptr);
311 if (useHalfPlaneApprox) {
312 profile.reset(create_half_plane_profile(kProfileTextureWidth));
313 } else {
314 // Rescale params to the size of the texture we're creating.
315 SkScalar scale = kProfileTextureWidth / *textureRadius;
316 profile.reset(create_circle_profile(sigma * scale, circleR * scale,
317 kProfileTextureWidth));
318 }
319
320 blurProfile = GrSurfaceProxy::MakeDeferred(resourceProvider,
321 texDesc, SkBudgeted::kYes, profile.get(), 0);
322 if (!blurProfile) {
323 return nullptr;
324 }
325
326 resourceProvider->assignUniqueKeyToProxy(key, blurProfile.get());
327 }
328
329 return blurProfile;
330 }
331
332 //////////////////////////////////////////////////////////////////////////////
333
Make(GrResourceProvider * resourceProvider,const SkRect & circle,float sigma)334 sk_sp<GrFragmentProcessor> GrCircleBlurFragmentProcessor::Make(GrResourceProvider* resourceProvider,
335 const SkRect& circle, float sigma) {
336 float solidRadius;
337 float textureRadius;
338 sk_sp<GrTextureProxy> profile(create_profile_texture(resourceProvider, circle, sigma,
339 &solidRadius, &textureRadius));
340 if (!profile) {
341 return nullptr;
342 }
343 return sk_sp<GrFragmentProcessor>(new GrCircleBlurFragmentProcessor(resourceProvider,
344 circle,
345 textureRadius, solidRadius,
346 std::move(profile)));
347 }
348
349 //////////////////////////////////////////////////////////////////////////////
350
351 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrCircleBlurFragmentProcessor);
352
353 #if GR_TEST_UTILS
TestCreate(GrProcessorTestData * d)354 sk_sp<GrFragmentProcessor> GrCircleBlurFragmentProcessor::TestCreate(GrProcessorTestData* d) {
355 SkScalar wh = d->fRandom->nextRangeScalar(100.f, 1000.f);
356 SkScalar sigma = d->fRandom->nextRangeF(1.f,10.f);
357 SkRect circle = SkRect::MakeWH(wh, wh);
358 return GrCircleBlurFragmentProcessor::Make(d->resourceProvider(), circle, sigma);
359 }
360 #endif
361
362 #endif
363