OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2014 Google Inc. | 2 * Copyright 2014 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "gl/builders/GrGLProgramBuilder.h" | |
9 #include "GrOvalEffect.h" | 8 #include "GrOvalEffect.h" |
| 9 |
| 10 #include "GrFragmentProcessor.h" |
10 #include "GrInvariantOutput.h" | 11 #include "GrInvariantOutput.h" |
| 12 #include "SkRect.h" |
11 #include "gl/GrGLProcessor.h" | 13 #include "gl/GrGLProcessor.h" |
12 #include "gl/GrGLSL.h" | 14 #include "gl/GrGLSL.h" |
13 #include "GrTBackendProcessorFactory.h" | 15 #include "gl/builders/GrGLProgramBuilder.h" |
14 | |
15 #include "SkRect.h" | |
16 | 16 |
17 ////////////////////////////////////////////////////////////////////////////// | 17 ////////////////////////////////////////////////////////////////////////////// |
18 | 18 |
19 class GLCircleEffect; | |
20 | |
21 class CircleEffect : public GrFragmentProcessor { | 19 class CircleEffect : public GrFragmentProcessor { |
22 public: | 20 public: |
23 static GrFragmentProcessor* Create(GrPrimitiveEdgeType, const SkPoint& cente
r, SkScalar radius); | 21 static GrFragmentProcessor* Create(GrPrimitiveEdgeType, const SkPoint& cente
r, SkScalar radius); |
24 | 22 |
25 virtual ~CircleEffect() {}; | 23 virtual ~CircleEffect() {}; |
26 static const char* Name() { return "Circle"; } | 24 |
| 25 virtual const char* name() const SK_OVERRIDE { return "Circle"; } |
| 26 |
| 27 virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) cons
t SK_OVERRIDE; |
| 28 |
| 29 virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE; |
27 | 30 |
28 const SkPoint& getCenter() const { return fCenter; } | 31 const SkPoint& getCenter() const { return fCenter; } |
29 SkScalar getRadius() const { return fRadius; } | 32 SkScalar getRadius() const { return fRadius; } |
30 | 33 |
31 GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; } | 34 GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; } |
32 | 35 |
33 typedef GLCircleEffect GLProcessor; | |
34 | |
35 virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERR
IDE; | |
36 | |
37 private: | 36 private: |
38 CircleEffect(GrPrimitiveEdgeType, const SkPoint& center, SkScalar radius); | 37 CircleEffect(GrPrimitiveEdgeType, const SkPoint& center, SkScalar radius); |
39 | 38 |
40 virtual bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE; | 39 virtual bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE; |
41 | 40 |
42 virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVE
RRIDE; | 41 virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVE
RRIDE; |
43 | 42 |
44 SkPoint fCenter; | 43 SkPoint fCenter; |
45 SkScalar fRadius; | 44 SkScalar fRadius; |
46 GrPrimitiveEdgeType fEdgeType; | 45 GrPrimitiveEdgeType fEdgeType; |
47 | 46 |
48 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; | 47 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; |
49 | 48 |
50 typedef GrFragmentProcessor INHERITED; | 49 typedef GrFragmentProcessor INHERITED; |
51 }; | 50 }; |
52 | 51 |
53 GrFragmentProcessor* CircleEffect::Create(GrPrimitiveEdgeType edgeType, const Sk
Point& center, | 52 GrFragmentProcessor* CircleEffect::Create(GrPrimitiveEdgeType edgeType, const Sk
Point& center, |
54 SkScalar radius) { | 53 SkScalar radius) { |
55 SkASSERT(radius >= 0); | 54 SkASSERT(radius >= 0); |
56 return SkNEW_ARGS(CircleEffect, (edgeType, center, radius)); | 55 return SkNEW_ARGS(CircleEffect, (edgeType, center, radius)); |
57 } | 56 } |
58 | 57 |
59 void CircleEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const { | 58 void CircleEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const { |
60 inout->mulByUnknownAlpha(); | 59 inout->mulByUnknownAlpha(); |
61 } | 60 } |
62 | 61 |
63 const GrBackendFragmentProcessorFactory& CircleEffect::getFactory() const { | |
64 return GrTBackendFragmentProcessorFactory<CircleEffect>::getInstance(); | |
65 } | |
66 | |
67 CircleEffect::CircleEffect(GrPrimitiveEdgeType edgeType, const SkPoint& c, SkSca
lar r) | 62 CircleEffect::CircleEffect(GrPrimitiveEdgeType edgeType, const SkPoint& c, SkSca
lar r) |
68 : fCenter(c) | 63 : fCenter(c) |
69 , fRadius(r) | 64 , fRadius(r) |
70 , fEdgeType(edgeType) { | 65 , fEdgeType(edgeType) { |
| 66 this->initClassID<CircleEffect>(); |
71 this->setWillReadFragmentPosition(); | 67 this->setWillReadFragmentPosition(); |
72 } | 68 } |
73 | 69 |
74 bool CircleEffect::onIsEqual(const GrFragmentProcessor& other) const { | 70 bool CircleEffect::onIsEqual(const GrFragmentProcessor& other) const { |
75 const CircleEffect& ce = other.cast<CircleEffect>(); | 71 const CircleEffect& ce = other.cast<CircleEffect>(); |
76 return fEdgeType == ce.fEdgeType && fCenter == ce.fCenter && fRadius == ce.f
Radius; | 72 return fEdgeType == ce.fEdgeType && fCenter == ce.fCenter && fRadius == ce.f
Radius; |
77 } | 73 } |
78 | 74 |
79 ////////////////////////////////////////////////////////////////////////////// | 75 ////////////////////////////////////////////////////////////////////////////// |
80 | 76 |
(...skipping 11 matching lines...) Expand all Loading... |
92 do { | 88 do { |
93 et = (GrPrimitiveEdgeType)random->nextULessThan(kGrProcessorEdgeTypeCnt)
; | 89 et = (GrPrimitiveEdgeType)random->nextULessThan(kGrProcessorEdgeTypeCnt)
; |
94 } while (kHairlineAA_GrProcessorEdgeType == et); | 90 } while (kHairlineAA_GrProcessorEdgeType == et); |
95 return CircleEffect::Create(et, center, radius); | 91 return CircleEffect::Create(et, center, radius); |
96 } | 92 } |
97 | 93 |
98 ////////////////////////////////////////////////////////////////////////////// | 94 ////////////////////////////////////////////////////////////////////////////// |
99 | 95 |
100 class GLCircleEffect : public GrGLFragmentProcessor { | 96 class GLCircleEffect : public GrGLFragmentProcessor { |
101 public: | 97 public: |
102 GLCircleEffect(const GrBackendProcessorFactory&, const GrProcessor&); | 98 GLCircleEffect(const GrProcessor&); |
103 | 99 |
104 virtual void emitCode(GrGLFPBuilder* builder, | 100 virtual void emitCode(GrGLFPBuilder* builder, |
105 const GrFragmentProcessor& fp, | 101 const GrFragmentProcessor& fp, |
106 const char* outputColor, | 102 const char* outputColor, |
107 const char* inputColor, | 103 const char* inputColor, |
108 const TransformedCoordsArray&, | 104 const TransformedCoordsArray&, |
109 const TextureSamplerArray&) SK_OVERRIDE; | 105 const TextureSamplerArray&) SK_OVERRIDE; |
110 | 106 |
111 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKe
yBuilder*); | 107 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKe
yBuilder*); |
112 | 108 |
113 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; | 109 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; |
114 | 110 |
115 private: | 111 private: |
116 GrGLProgramDataManager::UniformHandle fCircleUniform; | 112 GrGLProgramDataManager::UniformHandle fCircleUniform; |
117 SkPoint fPrevCenter; | 113 SkPoint fPrevCenter; |
118 SkScalar fPrevRadius; | 114 SkScalar fPrevRadius; |
119 | 115 |
120 typedef GrGLFragmentProcessor INHERITED; | 116 typedef GrGLFragmentProcessor INHERITED; |
121 }; | 117 }; |
122 | 118 |
123 GLCircleEffect::GLCircleEffect(const GrBackendProcessorFactory& factory, | 119 GLCircleEffect::GLCircleEffect(const GrProcessor&) { |
124 const GrProcessor&) | |
125 : INHERITED (factory) { | |
126 fPrevRadius = -1.f; | 120 fPrevRadius = -1.f; |
127 } | 121 } |
128 | 122 |
129 void GLCircleEffect::emitCode(GrGLFPBuilder* builder, | 123 void GLCircleEffect::emitCode(GrGLFPBuilder* builder, |
130 const GrFragmentProcessor& fp, | 124 const GrFragmentProcessor& fp, |
131 const char* outputColor, | 125 const char* outputColor, |
132 const char* inputColor, | 126 const char* inputColor, |
133 const TransformedCoordsArray&, | 127 const TransformedCoordsArray&, |
134 const TextureSamplerArray& samplers) { | 128 const TextureSamplerArray& samplers) { |
135 const CircleEffect& ce = fp.cast<CircleEffect>(); | 129 const CircleEffect& ce = fp.cast<CircleEffect>(); |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
176 radius -= 0.5f; | 170 radius -= 0.5f; |
177 } else { | 171 } else { |
178 radius += 0.5f; | 172 radius += 0.5f; |
179 } | 173 } |
180 pdman.set3f(fCircleUniform, ce.getCenter().fX, ce.getCenter().fY, radius
); | 174 pdman.set3f(fCircleUniform, ce.getCenter().fX, ce.getCenter().fY, radius
); |
181 fPrevCenter = ce.getCenter(); | 175 fPrevCenter = ce.getCenter(); |
182 fPrevRadius = ce.getRadius(); | 176 fPrevRadius = ce.getRadius(); |
183 } | 177 } |
184 } | 178 } |
185 | 179 |
| 180 ////////////////////////////////////////////////////////////////////////////////
/////////////////// |
| 181 |
| 182 void CircleEffect::getGLProcessorKey(const GrGLCaps& caps, |
| 183 GrProcessorKeyBuilder* b) const { |
| 184 GLCircleEffect::GenKey(*this, caps, b); |
| 185 } |
| 186 |
| 187 GrGLFragmentProcessor* CircleEffect::createGLInstance() const { |
| 188 return SkNEW_ARGS(GLCircleEffect, (*this)); |
| 189 } |
| 190 |
186 ////////////////////////////////////////////////////////////////////////////// | 191 ////////////////////////////////////////////////////////////////////////////// |
187 | 192 |
188 class GLEllipseEffect; | |
189 | |
190 class EllipseEffect : public GrFragmentProcessor { | 193 class EllipseEffect : public GrFragmentProcessor { |
191 public: | 194 public: |
192 static GrFragmentProcessor* Create(GrPrimitiveEdgeType, const SkPoint& cente
r, SkScalar rx, | 195 static GrFragmentProcessor* Create(GrPrimitiveEdgeType, const SkPoint& cente
r, SkScalar rx, |
193 SkScalar ry); | 196 SkScalar ry); |
194 | 197 |
195 virtual ~EllipseEffect() {}; | 198 virtual ~EllipseEffect() {}; |
196 static const char* Name() { return "Ellipse"; } | 199 |
| 200 virtual const char* name() const SK_OVERRIDE { return "Ellipse"; } |
| 201 |
| 202 virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) cons
t SK_OVERRIDE; |
| 203 |
| 204 virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE; |
197 | 205 |
198 const SkPoint& getCenter() const { return fCenter; } | 206 const SkPoint& getCenter() const { return fCenter; } |
199 SkVector getRadii() const { return fRadii; } | 207 SkVector getRadii() const { return fRadii; } |
200 | 208 |
201 GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; } | 209 GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; } |
202 | 210 |
203 typedef GLEllipseEffect GLProcessor; | |
204 | |
205 virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERR
IDE; | |
206 | |
207 private: | 211 private: |
208 EllipseEffect(GrPrimitiveEdgeType, const SkPoint& center, SkScalar rx, SkSca
lar ry); | 212 EllipseEffect(GrPrimitiveEdgeType, const SkPoint& center, SkScalar rx, SkSca
lar ry); |
209 | 213 |
210 virtual bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE; | 214 virtual bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE; |
211 | 215 |
212 virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVE
RRIDE; | 216 virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVE
RRIDE; |
213 | 217 |
214 SkPoint fCenter; | 218 SkPoint fCenter; |
215 SkVector fRadii; | 219 SkVector fRadii; |
216 GrPrimitiveEdgeType fEdgeType; | 220 GrPrimitiveEdgeType fEdgeType; |
217 | 221 |
218 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; | 222 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; |
219 | 223 |
220 typedef GrFragmentProcessor INHERITED; | 224 typedef GrFragmentProcessor INHERITED; |
221 }; | 225 }; |
222 | 226 |
223 GrFragmentProcessor* EllipseEffect::Create(GrPrimitiveEdgeType edgeType, | 227 GrFragmentProcessor* EllipseEffect::Create(GrPrimitiveEdgeType edgeType, |
224 const SkPoint& center, | 228 const SkPoint& center, |
225 SkScalar rx, | 229 SkScalar rx, |
226 SkScalar ry) { | 230 SkScalar ry) { |
227 SkASSERT(rx >= 0 && ry >= 0); | 231 SkASSERT(rx >= 0 && ry >= 0); |
228 return SkNEW_ARGS(EllipseEffect, (edgeType, center, rx, ry)); | 232 return SkNEW_ARGS(EllipseEffect, (edgeType, center, rx, ry)); |
229 } | 233 } |
230 | 234 |
231 void EllipseEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const { | 235 void EllipseEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const { |
232 inout->mulByUnknownAlpha(); | 236 inout->mulByUnknownAlpha(); |
233 } | 237 } |
234 | 238 |
235 const GrBackendFragmentProcessorFactory& EllipseEffect::getFactory() const { | |
236 return GrTBackendFragmentProcessorFactory<EllipseEffect>::getInstance(); | |
237 } | |
238 | |
239 EllipseEffect::EllipseEffect(GrPrimitiveEdgeType edgeType, const SkPoint& c, SkS
calar rx, SkScalar ry) | 239 EllipseEffect::EllipseEffect(GrPrimitiveEdgeType edgeType, const SkPoint& c, SkS
calar rx, SkScalar ry) |
240 : fCenter(c) | 240 : fCenter(c) |
241 , fRadii(SkVector::Make(rx, ry)) | 241 , fRadii(SkVector::Make(rx, ry)) |
242 , fEdgeType(edgeType) { | 242 , fEdgeType(edgeType) { |
| 243 this->initClassID<EllipseEffect>(); |
243 this->setWillReadFragmentPosition(); | 244 this->setWillReadFragmentPosition(); |
244 } | 245 } |
245 | 246 |
246 bool EllipseEffect::onIsEqual(const GrFragmentProcessor& other) const { | 247 bool EllipseEffect::onIsEqual(const GrFragmentProcessor& other) const { |
247 const EllipseEffect& ee = other.cast<EllipseEffect>(); | 248 const EllipseEffect& ee = other.cast<EllipseEffect>(); |
248 return fEdgeType == ee.fEdgeType && fCenter == ee.fCenter && fRadii == ee.fR
adii; | 249 return fEdgeType == ee.fEdgeType && fCenter == ee.fCenter && fRadii == ee.fR
adii; |
249 } | 250 } |
250 | 251 |
251 ////////////////////////////////////////////////////////////////////////////// | 252 ////////////////////////////////////////////////////////////////////////////// |
252 | 253 |
(...skipping 12 matching lines...) Expand all Loading... |
265 do { | 266 do { |
266 et = (GrPrimitiveEdgeType)random->nextULessThan(kGrProcessorEdgeTypeCnt)
; | 267 et = (GrPrimitiveEdgeType)random->nextULessThan(kGrProcessorEdgeTypeCnt)
; |
267 } while (kHairlineAA_GrProcessorEdgeType == et); | 268 } while (kHairlineAA_GrProcessorEdgeType == et); |
268 return EllipseEffect::Create(et, center, rx, ry); | 269 return EllipseEffect::Create(et, center, rx, ry); |
269 } | 270 } |
270 | 271 |
271 ////////////////////////////////////////////////////////////////////////////// | 272 ////////////////////////////////////////////////////////////////////////////// |
272 | 273 |
273 class GLEllipseEffect : public GrGLFragmentProcessor { | 274 class GLEllipseEffect : public GrGLFragmentProcessor { |
274 public: | 275 public: |
275 GLEllipseEffect(const GrBackendProcessorFactory&, const GrProcessor&); | 276 GLEllipseEffect(const GrProcessor&); |
276 | 277 |
277 virtual void emitCode(GrGLFPBuilder* builder, | 278 virtual void emitCode(GrGLFPBuilder* builder, |
278 const GrFragmentProcessor& fp, | 279 const GrFragmentProcessor& fp, |
279 const char* outputColor, | 280 const char* outputColor, |
280 const char* inputColor, | 281 const char* inputColor, |
281 const TransformedCoordsArray&, | 282 const TransformedCoordsArray&, |
282 const TextureSamplerArray&) SK_OVERRIDE; | 283 const TextureSamplerArray&) SK_OVERRIDE; |
283 | 284 |
284 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKe
yBuilder*); | 285 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKe
yBuilder*); |
285 | 286 |
286 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; | 287 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_O
VERRIDE; |
287 | 288 |
288 private: | 289 private: |
289 GrGLProgramDataManager::UniformHandle fEllipseUniform; | 290 GrGLProgramDataManager::UniformHandle fEllipseUniform; |
290 SkPoint fPrevCenter; | 291 SkPoint fPrevCenter; |
291 SkVector fPrevRadii; | 292 SkVector fPrevRadii; |
292 | 293 |
293 typedef GrGLFragmentProcessor INHERITED; | 294 typedef GrGLFragmentProcessor INHERITED; |
294 }; | 295 }; |
295 | 296 |
296 GLEllipseEffect::GLEllipseEffect(const GrBackendProcessorFactory& factory, | 297 GLEllipseEffect::GLEllipseEffect(const GrProcessor& effect) { |
297 const GrProcessor& effect) | |
298 : INHERITED (factory) { | |
299 fPrevRadii.fX = -1.f; | 298 fPrevRadii.fX = -1.f; |
300 } | 299 } |
301 | 300 |
302 void GLEllipseEffect::emitCode(GrGLFPBuilder* builder, | 301 void GLEllipseEffect::emitCode(GrGLFPBuilder* builder, |
303 const GrFragmentProcessor& fp, | 302 const GrFragmentProcessor& fp, |
304 const char* outputColor, | 303 const char* outputColor, |
305 const char* inputColor, | 304 const char* inputColor, |
306 const TransformedCoordsArray&, | 305 const TransformedCoordsArray&, |
307 const TextureSamplerArray& samplers) { | 306 const TextureSamplerArray& samplers) { |
308 const EllipseEffect& ee = fp.cast<EllipseEffect>(); | 307 const EllipseEffect& ee = fp.cast<EllipseEffect>(); |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
358 const EllipseEffect& ee = effect.cast<EllipseEffect>(); | 357 const EllipseEffect& ee = effect.cast<EllipseEffect>(); |
359 if (ee.getRadii() != fPrevRadii || ee.getCenter() != fPrevCenter) { | 358 if (ee.getRadii() != fPrevRadii || ee.getCenter() != fPrevCenter) { |
360 SkScalar invRXSqd = 1.f / (ee.getRadii().fX * ee.getRadii().fX); | 359 SkScalar invRXSqd = 1.f / (ee.getRadii().fX * ee.getRadii().fX); |
361 SkScalar invRYSqd = 1.f / (ee.getRadii().fY * ee.getRadii().fY); | 360 SkScalar invRYSqd = 1.f / (ee.getRadii().fY * ee.getRadii().fY); |
362 pdman.set4f(fEllipseUniform, ee.getCenter().fX, ee.getCenter().fY, invRX
Sqd, invRYSqd); | 361 pdman.set4f(fEllipseUniform, ee.getCenter().fX, ee.getCenter().fY, invRX
Sqd, invRYSqd); |
363 fPrevCenter = ee.getCenter(); | 362 fPrevCenter = ee.getCenter(); |
364 fPrevRadii = ee.getRadii(); | 363 fPrevRadii = ee.getRadii(); |
365 } | 364 } |
366 } | 365 } |
367 | 366 |
| 367 ////////////////////////////////////////////////////////////////////////////////
/////////////////// |
| 368 |
| 369 void EllipseEffect::getGLProcessorKey(const GrGLCaps& caps, |
| 370 GrProcessorKeyBuilder* b) const { |
| 371 GLEllipseEffect::GenKey(*this, caps, b); |
| 372 } |
| 373 |
| 374 GrGLFragmentProcessor* EllipseEffect::createGLInstance() const { |
| 375 return SkNEW_ARGS(GLEllipseEffect, (*this)); |
| 376 } |
| 377 |
368 ////////////////////////////////////////////////////////////////////////////// | 378 ////////////////////////////////////////////////////////////////////////////// |
369 | 379 |
370 GrFragmentProcessor* GrOvalEffect::Create(GrPrimitiveEdgeType edgeType, const Sk
Rect& oval) { | 380 GrFragmentProcessor* GrOvalEffect::Create(GrPrimitiveEdgeType edgeType, const Sk
Rect& oval) { |
371 if (kHairlineAA_GrProcessorEdgeType == edgeType) { | 381 if (kHairlineAA_GrProcessorEdgeType == edgeType) { |
372 return NULL; | 382 return NULL; |
373 } | 383 } |
374 SkScalar w = oval.width(); | 384 SkScalar w = oval.width(); |
375 SkScalar h = oval.height(); | 385 SkScalar h = oval.height(); |
376 if (SkScalarNearlyEqual(w, h)) { | 386 if (SkScalarNearlyEqual(w, h)) { |
377 w /= 2; | 387 w /= 2; |
378 return CircleEffect::Create(edgeType, SkPoint::Make(oval.fLeft + w, oval
.fTop + w), w); | 388 return CircleEffect::Create(edgeType, SkPoint::Make(oval.fLeft + w, oval
.fTop + w), w); |
379 } else { | 389 } else { |
380 w /= 2; | 390 w /= 2; |
381 h /= 2; | 391 h /= 2; |
382 return EllipseEffect::Create(edgeType, SkPoint::Make(oval.fLeft + w, ova
l.fTop + h), w, h); | 392 return EllipseEffect::Create(edgeType, SkPoint::Make(oval.fLeft + w, ova
l.fTop + h), w, h); |
383 } | 393 } |
384 | 394 |
385 return NULL; | 395 return NULL; |
386 } | 396 } |
OLD | NEW |