1 /*
2 * Copyright 2014 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 "GrOvalEffect.h"
9
10 #include "GrFragmentProcessor.h"
11 #include "GrInvariantOutput.h"
12 #include "SkRect.h"
13 #include "glsl/GrGLSLFragmentProcessor.h"
14 #include "glsl/GrGLSLFragmentShaderBuilder.h"
15 #include "glsl/GrGLSLProgramDataManager.h"
16 #include "glsl/GrGLSLUniformHandler.h"
17
18 //////////////////////////////////////////////////////////////////////////////
19
20 class CircleEffect : public GrFragmentProcessor {
21 public:
22 static GrFragmentProcessor* Create(GrPrimitiveEdgeType, const SkPoint& center, SkScalar radius);
23
~CircleEffect()24 virtual ~CircleEffect() {};
25
name() const26 const char* name() const override { return "Circle"; }
27
getCenter() const28 const SkPoint& getCenter() const { return fCenter; }
getRadius() const29 SkScalar getRadius() const { return fRadius; }
30
getEdgeType() const31 GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
32
33 private:
34 CircleEffect(GrPrimitiveEdgeType, const SkPoint& center, SkScalar radius);
35
36 GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
37
38 void onGetGLSLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
39
40 bool onIsEqual(const GrFragmentProcessor&) const override;
41
42 void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
43
44 SkPoint fCenter;
45 SkScalar fRadius;
46 GrPrimitiveEdgeType fEdgeType;
47
48 GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
49
50 typedef GrFragmentProcessor INHERITED;
51 };
52
Create(GrPrimitiveEdgeType edgeType,const SkPoint & center,SkScalar radius)53 GrFragmentProcessor* CircleEffect::Create(GrPrimitiveEdgeType edgeType, const SkPoint& center,
54 SkScalar radius) {
55 SkASSERT(radius >= 0);
56 return new CircleEffect(edgeType, center, radius);
57 }
58
onComputeInvariantOutput(GrInvariantOutput * inout) const59 void CircleEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
60 inout->mulByUnknownSingleComponent();
61 }
62
CircleEffect(GrPrimitiveEdgeType edgeType,const SkPoint & c,SkScalar r)63 CircleEffect::CircleEffect(GrPrimitiveEdgeType edgeType, const SkPoint& c, SkScalar r)
64 : fCenter(c)
65 , fRadius(r)
66 , fEdgeType(edgeType) {
67 this->initClassID<CircleEffect>();
68 this->setWillReadFragmentPosition();
69 }
70
onIsEqual(const GrFragmentProcessor & other) const71 bool CircleEffect::onIsEqual(const GrFragmentProcessor& other) const {
72 const CircleEffect& ce = other.cast<CircleEffect>();
73 return fEdgeType == ce.fEdgeType && fCenter == ce.fCenter && fRadius == ce.fRadius;
74 }
75
76 //////////////////////////////////////////////////////////////////////////////
77
78 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleEffect);
79
TestCreate(GrProcessorTestData * d)80 const GrFragmentProcessor* CircleEffect::TestCreate(GrProcessorTestData* d) {
81 SkPoint center;
82 center.fX = d->fRandom->nextRangeScalar(0.f, 1000.f);
83 center.fY = d->fRandom->nextRangeScalar(0.f, 1000.f);
84 SkScalar radius = d->fRandom->nextRangeF(0.f, 1000.f);
85 GrPrimitiveEdgeType et;
86 do {
87 et = (GrPrimitiveEdgeType)d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt);
88 } while (kHairlineAA_GrProcessorEdgeType == et);
89 return CircleEffect::Create(et, center, radius);
90 }
91
92 //////////////////////////////////////////////////////////////////////////////
93
94 class GLCircleEffect : public GrGLSLFragmentProcessor {
95 public:
GLCircleEffect()96 GLCircleEffect() : fPrevRadius(-1.0f) { }
97
98 virtual void emitCode(EmitArgs&) override;
99
100 static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
101
102 protected:
103 void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
104
105 private:
106 GrGLSLProgramDataManager::UniformHandle fCircleUniform;
107 SkPoint fPrevCenter;
108 SkScalar fPrevRadius;
109
110 typedef GrGLSLFragmentProcessor INHERITED;
111 };
112
emitCode(EmitArgs & args)113 void GLCircleEffect::emitCode(EmitArgs& args) {
114 const CircleEffect& ce = args.fFp.cast<CircleEffect>();
115 const char *circleName;
116 // The circle uniform is (center.x, center.y, radius + 0.5, 1 / (radius + 0.5)) for regular
117 // fills and (..., radius - 0.5, 1 / (radius - 0.5)) for inverse fills.
118 fCircleUniform = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
119 kVec4f_GrSLType, kDefault_GrSLPrecision,
120 "circle",
121 &circleName);
122
123 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
124 const char* fragmentPos = fragBuilder->fragmentPosition();
125
126 SkASSERT(kHairlineAA_GrProcessorEdgeType != ce.getEdgeType());
127 // TODO: Right now the distance to circle caclulation is performed in a space normalized to the
128 // radius and then denormalized. This is to prevent overflow on devices that have a "real"
129 // mediump. It'd be nice to only to this on mediump devices but we currently don't have the
130 // caps here.
131 if (GrProcessorEdgeTypeIsInverseFill(ce.getEdgeType())) {
132 fragBuilder->codeAppendf("float d = (length((%s.xy - %s.xy) * %s.w) - 1.0) * %s.z;",
133 circleName, fragmentPos, circleName, circleName);
134 } else {
135 fragBuilder->codeAppendf("float d = (1.0 - length((%s.xy - %s.xy) * %s.w)) * %s.z;",
136 circleName, fragmentPos, circleName, circleName);
137 }
138 if (GrProcessorEdgeTypeIsAA(ce.getEdgeType())) {
139 fragBuilder->codeAppend("d = clamp(d, 0.0, 1.0);");
140 } else {
141 fragBuilder->codeAppend("d = d > 0.5 ? 1.0 : 0.0;");
142 }
143
144 fragBuilder->codeAppendf("%s = %s;", args.fOutputColor,
145 (GrGLSLExpr4(args.fInputColor) * GrGLSLExpr1("d")).c_str());
146 }
147
GenKey(const GrProcessor & processor,const GrGLSLCaps &,GrProcessorKeyBuilder * b)148 void GLCircleEffect::GenKey(const GrProcessor& processor, const GrGLSLCaps&,
149 GrProcessorKeyBuilder* b) {
150 const CircleEffect& ce = processor.cast<CircleEffect>();
151 b->add32(ce.getEdgeType());
152 }
153
onSetData(const GrGLSLProgramDataManager & pdman,const GrProcessor & processor)154 void GLCircleEffect::onSetData(const GrGLSLProgramDataManager& pdman,
155 const GrProcessor& processor) {
156 const CircleEffect& ce = processor.cast<CircleEffect>();
157 if (ce.getRadius() != fPrevRadius || ce.getCenter() != fPrevCenter) {
158 SkScalar radius = ce.getRadius();
159 if (GrProcessorEdgeTypeIsInverseFill(ce.getEdgeType())) {
160 radius -= 0.5f;
161 } else {
162 radius += 0.5f;
163 }
164 pdman.set4f(fCircleUniform, ce.getCenter().fX, ce.getCenter().fY, radius,
165 SkScalarInvert(radius));
166 fPrevCenter = ce.getCenter();
167 fPrevRadius = ce.getRadius();
168 }
169 }
170
171 ///////////////////////////////////////////////////////////////////////////////////////////////////
172
onGetGLSLProcessorKey(const GrGLSLCaps & caps,GrProcessorKeyBuilder * b) const173 void CircleEffect::onGetGLSLProcessorKey(const GrGLSLCaps& caps,
174 GrProcessorKeyBuilder* b) const {
175 GLCircleEffect::GenKey(*this, caps, b);
176 }
177
onCreateGLSLInstance() const178 GrGLSLFragmentProcessor* CircleEffect::onCreateGLSLInstance() const {
179 return new GLCircleEffect;
180 }
181
182 //////////////////////////////////////////////////////////////////////////////
183
184 class EllipseEffect : public GrFragmentProcessor {
185 public:
186 static GrFragmentProcessor* Create(GrPrimitiveEdgeType, const SkPoint& center, SkScalar rx,
187 SkScalar ry);
188
~EllipseEffect()189 virtual ~EllipseEffect() {};
190
name() const191 const char* name() const override { return "Ellipse"; }
192
getCenter() const193 const SkPoint& getCenter() const { return fCenter; }
getRadii() const194 SkVector getRadii() const { return fRadii; }
195
getEdgeType() const196 GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
197
198 private:
199 EllipseEffect(GrPrimitiveEdgeType, const SkPoint& center, SkScalar rx, SkScalar ry);
200
201 GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
202
203 void onGetGLSLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
204
205 bool onIsEqual(const GrFragmentProcessor&) const override;
206
207 void onComputeInvariantOutput(GrInvariantOutput* inout) const override;
208
209 SkPoint fCenter;
210 SkVector fRadii;
211 GrPrimitiveEdgeType fEdgeType;
212
213 GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
214
215 typedef GrFragmentProcessor INHERITED;
216 };
217
Create(GrPrimitiveEdgeType edgeType,const SkPoint & center,SkScalar rx,SkScalar ry)218 GrFragmentProcessor* EllipseEffect::Create(GrPrimitiveEdgeType edgeType,
219 const SkPoint& center,
220 SkScalar rx,
221 SkScalar ry) {
222 SkASSERT(rx >= 0 && ry >= 0);
223 return new EllipseEffect(edgeType, center, rx, ry);
224 }
225
onComputeInvariantOutput(GrInvariantOutput * inout) const226 void EllipseEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
227 inout->mulByUnknownSingleComponent();
228 }
229
EllipseEffect(GrPrimitiveEdgeType edgeType,const SkPoint & c,SkScalar rx,SkScalar ry)230 EllipseEffect::EllipseEffect(GrPrimitiveEdgeType edgeType, const SkPoint& c, SkScalar rx, SkScalar ry)
231 : fCenter(c)
232 , fRadii(SkVector::Make(rx, ry))
233 , fEdgeType(edgeType) {
234 this->initClassID<EllipseEffect>();
235 this->setWillReadFragmentPosition();
236 }
237
onIsEqual(const GrFragmentProcessor & other) const238 bool EllipseEffect::onIsEqual(const GrFragmentProcessor& other) const {
239 const EllipseEffect& ee = other.cast<EllipseEffect>();
240 return fEdgeType == ee.fEdgeType && fCenter == ee.fCenter && fRadii == ee.fRadii;
241 }
242
243 //////////////////////////////////////////////////////////////////////////////
244
245 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(EllipseEffect);
246
TestCreate(GrProcessorTestData * d)247 const GrFragmentProcessor* EllipseEffect::TestCreate(GrProcessorTestData* d) {
248 SkPoint center;
249 center.fX = d->fRandom->nextRangeScalar(0.f, 1000.f);
250 center.fY = d->fRandom->nextRangeScalar(0.f, 1000.f);
251 SkScalar rx = d->fRandom->nextRangeF(0.f, 1000.f);
252 SkScalar ry = d->fRandom->nextRangeF(0.f, 1000.f);
253 GrPrimitiveEdgeType et;
254 do {
255 et = (GrPrimitiveEdgeType)d->fRandom->nextULessThan(kGrProcessorEdgeTypeCnt);
256 } while (kHairlineAA_GrProcessorEdgeType == et);
257 return EllipseEffect::Create(et, center, rx, ry);
258 }
259
260 //////////////////////////////////////////////////////////////////////////////
261
262 class GLEllipseEffect : public GrGLSLFragmentProcessor {
263 public:
GLEllipseEffect()264 GLEllipseEffect() {
265 fPrevRadii.fX = -1.0f;
266 }
267
268 void emitCode(EmitArgs&) override;
269
270 static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
271
272 protected:
273 void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
274
275 private:
276 GrGLSLProgramDataManager::UniformHandle fEllipseUniform;
277 GrGLSLProgramDataManager::UniformHandle fScaleUniform;
278 SkPoint fPrevCenter;
279 SkVector fPrevRadii;
280
281 typedef GrGLSLFragmentProcessor INHERITED;
282 };
283
emitCode(EmitArgs & args)284 void GLEllipseEffect::emitCode(EmitArgs& args) {
285 const EllipseEffect& ee = args.fFp.cast<EllipseEffect>();
286 const char *ellipseName;
287 // The ellipse uniform is (center.x, center.y, 1 / rx^2, 1 / ry^2)
288 // The last two terms can underflow on mediump, so we use highp.
289 fEllipseUniform = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
290 kVec4f_GrSLType, kHigh_GrSLPrecision,
291 "ellipse",
292 &ellipseName);
293 // If we're on a device with a "real" mediump then we'll do the distance computation in a space
294 // that is normalized by the larger radius. The scale uniform will be scale, 1/scale. The
295 // inverse squared radii uniform values are already in this normalized space. The center is
296 // not.
297 const char* scaleName = nullptr;
298 if (args.fGLSLCaps->floatPrecisionVaries()) {
299 fScaleUniform = args.fUniformHandler->addUniform(
300 kFragment_GrShaderFlag, kVec2f_GrSLType, kDefault_GrSLPrecision,
301 "scale", &scaleName);
302 }
303
304 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
305 const char* fragmentPos = fragBuilder->fragmentPosition();
306
307 // d is the offset to the ellipse center
308 fragBuilder->codeAppendf("vec2 d = %s.xy - %s.xy;", fragmentPos, ellipseName);
309 if (scaleName) {
310 fragBuilder->codeAppendf("d *= %s.y;", scaleName);
311 }
312 fragBuilder->codeAppendf("vec2 Z = d * %s.zw;", ellipseName);
313 // implicit is the evaluation of (x/rx)^2 + (y/ry)^2 - 1.
314 fragBuilder->codeAppend("float implicit = dot(Z, d) - 1.0;");
315 // grad_dot is the squared length of the gradient of the implicit.
316 fragBuilder->codeAppendf("float grad_dot = 4.0 * dot(Z, Z);");
317 // Avoid calling inversesqrt on zero.
318 fragBuilder->codeAppend("grad_dot = max(grad_dot, 1.0e-4);");
319 fragBuilder->codeAppendf("float approx_dist = implicit * inversesqrt(grad_dot);");
320 if (scaleName) {
321 fragBuilder->codeAppendf("approx_dist *= %s.x;", scaleName);
322 }
323
324 switch (ee.getEdgeType()) {
325 case kFillAA_GrProcessorEdgeType:
326 fragBuilder->codeAppend("float alpha = clamp(0.5 - approx_dist, 0.0, 1.0);");
327 break;
328 case kInverseFillAA_GrProcessorEdgeType:
329 fragBuilder->codeAppend("float alpha = clamp(0.5 + approx_dist, 0.0, 1.0);");
330 break;
331 case kFillBW_GrProcessorEdgeType:
332 fragBuilder->codeAppend("float alpha = approx_dist > 0.0 ? 0.0 : 1.0;");
333 break;
334 case kInverseFillBW_GrProcessorEdgeType:
335 fragBuilder->codeAppend("float alpha = approx_dist > 0.0 ? 1.0 : 0.0;");
336 break;
337 case kHairlineAA_GrProcessorEdgeType:
338 SkFAIL("Hairline not expected here.");
339 }
340
341 fragBuilder->codeAppendf("%s = %s;", args.fOutputColor,
342 (GrGLSLExpr4(args.fInputColor) * GrGLSLExpr1("alpha")).c_str());
343 }
344
GenKey(const GrProcessor & effect,const GrGLSLCaps &,GrProcessorKeyBuilder * b)345 void GLEllipseEffect::GenKey(const GrProcessor& effect, const GrGLSLCaps&,
346 GrProcessorKeyBuilder* b) {
347 const EllipseEffect& ee = effect.cast<EllipseEffect>();
348 b->add32(ee.getEdgeType());
349 }
350
onSetData(const GrGLSLProgramDataManager & pdman,const GrProcessor & effect)351 void GLEllipseEffect::onSetData(const GrGLSLProgramDataManager& pdman,
352 const GrProcessor& effect) {
353 const EllipseEffect& ee = effect.cast<EllipseEffect>();
354 if (ee.getRadii() != fPrevRadii || ee.getCenter() != fPrevCenter) {
355 float invRXSqd;
356 float invRYSqd;
357 // If we're using a scale factor to work around precision issues, choose the larger radius
358 // as the scale factor. The inv radii need to be pre-adjusted by the scale factor.
359 if (fScaleUniform.isValid()) {
360 if (ee.getRadii().fX > ee.getRadii().fY) {
361 invRXSqd = 1.f;
362 invRYSqd = (ee.getRadii().fX * ee.getRadii().fX) /
363 (ee.getRadii().fY * ee.getRadii().fY);
364 pdman.set2f(fScaleUniform, ee.getRadii().fX, 1.f / ee.getRadii().fX);
365 } else {
366 invRXSqd = (ee.getRadii().fY * ee.getRadii().fY) /
367 (ee.getRadii().fX * ee.getRadii().fX);
368 invRYSqd = 1.f;
369 pdman.set2f(fScaleUniform, ee.getRadii().fY, 1.f / ee.getRadii().fY);
370 }
371 } else {
372 invRXSqd = 1.f / (ee.getRadii().fX * ee.getRadii().fX);
373 invRYSqd = 1.f / (ee.getRadii().fY * ee.getRadii().fY);
374 }
375 pdman.set4f(fEllipseUniform, ee.getCenter().fX, ee.getCenter().fY, invRXSqd, invRYSqd);
376 fPrevCenter = ee.getCenter();
377 fPrevRadii = ee.getRadii();
378 }
379 }
380
381 ///////////////////////////////////////////////////////////////////////////////////////////////////
382
onGetGLSLProcessorKey(const GrGLSLCaps & caps,GrProcessorKeyBuilder * b) const383 void EllipseEffect::onGetGLSLProcessorKey(const GrGLSLCaps& caps,
384 GrProcessorKeyBuilder* b) const {
385 GLEllipseEffect::GenKey(*this, caps, b);
386 }
387
onCreateGLSLInstance() const388 GrGLSLFragmentProcessor* EllipseEffect::onCreateGLSLInstance() const {
389 return new GLEllipseEffect;
390 }
391
392 //////////////////////////////////////////////////////////////////////////////
393
Create(GrPrimitiveEdgeType edgeType,const SkRect & oval)394 GrFragmentProcessor* GrOvalEffect::Create(GrPrimitiveEdgeType edgeType, const SkRect& oval) {
395 if (kHairlineAA_GrProcessorEdgeType == edgeType) {
396 return nullptr;
397 }
398 SkScalar w = oval.width();
399 SkScalar h = oval.height();
400 if (SkScalarNearlyEqual(w, h)) {
401 w /= 2;
402 return CircleEffect::Create(edgeType, SkPoint::Make(oval.fLeft + w, oval.fTop + w), w);
403 } else {
404 w /= 2;
405 h /= 2;
406 return EllipseEffect::Create(edgeType, SkPoint::Make(oval.fLeft + w, oval.fTop + h), w, h);
407 }
408
409 return nullptr;
410 }
411