Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(485)

Side by Side Diff: src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp

Issue 571163002: removing GrDrawEffect (Closed) Base URL: https://skia.googlesource.com/skia.git@gp3
Patch Set: rebase after revert Created 6 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 1
2 /* 2 /*
3 * Copyright 2014 Google Inc. 3 * Copyright 2014 Google Inc.
4 * 4 *
5 * Use of this source code is governed by a BSD-style license that can be 5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file. 6 * found in the LICENSE file.
7 */ 7 */
8 8
9 #include "SkTwoPointConicalGradient_gpu.h" 9 #include "SkTwoPointConicalGradient_gpu.h"
10 10
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after
74 74
75 // The radial gradient parameters can collapse to a linear (instead of quadr atic) equation. 75 // The radial gradient parameters can collapse to a linear (instead of quadr atic) equation.
76 SkScalar center() const { return fCenterX1; } 76 SkScalar center() const { return fCenterX1; }
77 SkScalar diffRadius() const { return fDiffRadius; } 77 SkScalar diffRadius() const { return fDiffRadius; }
78 SkScalar radius() const { return fRadius0; } 78 SkScalar radius() const { return fRadius0; }
79 79
80 typedef GLEdge2PtConicalEffect GLEffect; 80 typedef GLEdge2PtConicalEffect GLEffect;
81 81
82 private: 82 private:
83 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE { 83 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
84 const Edge2PtConicalEffect& s = CastEffect<Edge2PtConicalEffect>(sBase); 84 const Edge2PtConicalEffect& s = sBase.cast<Edge2PtConicalEffect>();
85 return (INHERITED::onIsEqual(sBase) && 85 return (INHERITED::onIsEqual(sBase) &&
86 this->fCenterX1 == s.fCenterX1 && 86 this->fCenterX1 == s.fCenterX1 &&
87 this->fRadius0 == s.fRadius0 && 87 this->fRadius0 == s.fRadius0 &&
88 this->fDiffRadius == s.fDiffRadius); 88 this->fDiffRadius == s.fDiffRadius);
89 } 89 }
90 90
91 Edge2PtConicalEffect(GrContext* ctx, 91 Edge2PtConicalEffect(GrContext* ctx,
92 const SkTwoPointConicalGradient& shader, 92 const SkTwoPointConicalGradient& shader,
93 const SkMatrix& matrix, 93 const SkMatrix& matrix,
94 SkShader::TileMode tm) 94 SkShader::TileMode tm)
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after
127 SkScalar fRadius0; 127 SkScalar fRadius0;
128 SkScalar fDiffRadius; 128 SkScalar fDiffRadius;
129 129
130 // @} 130 // @}
131 131
132 typedef GrGradientEffect INHERITED; 132 typedef GrGradientEffect INHERITED;
133 }; 133 };
134 134
135 class GLEdge2PtConicalEffect : public GrGLGradientEffect { 135 class GLEdge2PtConicalEffect : public GrGLGradientEffect {
136 public: 136 public:
137 GLEdge2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDrawEf fect&); 137 GLEdge2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect &);
138 virtual ~GLEdge2PtConicalEffect() { } 138 virtual ~GLEdge2PtConicalEffect() { }
139 139
140 virtual void emitCode(GrGLProgramBuilder*, 140 virtual void emitCode(GrGLProgramBuilder*,
141 const GrDrawEffect&, 141 const GrEffect&,
142 const GrEffectKey&, 142 const GrEffectKey&,
143 const char* outputColor, 143 const char* outputColor,
144 const char* inputColor, 144 const char* inputColor,
145 const TransformedCoordsArray&, 145 const TransformedCoordsArray&,
146 const TextureSamplerArray&) SK_OVERRIDE; 146 const TextureSamplerArray&) SK_OVERRIDE;
147 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_ OVERRIDE; 147 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER RIDE;
148 148
149 static void GenKey(const GrDrawEffect&, const GrGLCaps& caps, GrEffectKeyBui lder* b); 149 static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder * b);
150 150
151 protected: 151 protected:
152 UniformHandle fParamUni; 152 UniformHandle fParamUni;
153 153
154 const char* fVSVaryingName; 154 const char* fVSVaryingName;
155 const char* fFSVaryingName; 155 const char* fFSVaryingName;
156 156
157 // @{ 157 // @{
158 /// Values last uploaded as uniforms 158 /// Values last uploaded as uniforms
159 159
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
203 colors , stops, colorCount, 203 colors , stops, colorCount,
204 tm)); 204 tm));
205 SkPaint paint; 205 SkPaint paint;
206 GrEffect* effect; 206 GrEffect* effect;
207 GrColor paintColor; 207 GrColor paintColor;
208 SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effec t)); 208 SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effec t));
209 return effect; 209 return effect;
210 } 210 }
211 211
212 GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrBackendEffectFactory& fac tory, 212 GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrBackendEffectFactory& fac tory,
213 const GrDrawEffect& drawEffect) 213 const GrEffect& effect)
214 : INHERITED(factory) 214 : INHERITED(factory)
215 , fVSVaryingName(NULL) 215 , fVSVaryingName(NULL)
216 , fFSVaryingName(NULL) 216 , fFSVaryingName(NULL)
217 , fCachedRadius(-SK_ScalarMax) 217 , fCachedRadius(-SK_ScalarMax)
218 , fCachedDiffRadius(-SK_ScalarMax) {} 218 , fCachedDiffRadius(-SK_ScalarMax) {}
219 219
220 void GLEdge2PtConicalEffect::emitCode(GrGLProgramBuilder* builder, 220 void GLEdge2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,
221 const GrDrawEffect&, 221 const GrEffect&,
222 const GrEffectKey& key, 222 const GrEffectKey& key,
223 const char* outputColor, 223 const char* outputColor,
224 const char* inputColor, 224 const char* inputColor,
225 const TransformedCoordsArray& coords, 225 const TransformedCoordsArray& coords,
226 const TextureSamplerArray& samplers) { 226 const TextureSamplerArray& samplers) {
227 uint32_t baseKey = key.get32(0); 227 uint32_t baseKey = key.get32(0);
228 this->emitUniforms(builder, baseKey); 228 this->emitUniforms(builder, baseKey);
229 fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibilit y, 229 fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibilit y,
230 kFloat_GrSLType, "Conical2FSParams", 3) ; 230 kFloat_GrSLType, "Conical2FSParams", 3) ;
231 231
232 SkString cName("c"); 232 SkString cName("c");
233 SkString tName("t"); 233 SkString tName("t");
234 SkString p0; // start radius 234 SkString p0; // start radius
235 SkString p1; // start radius squared 235 SkString p1; // start radius squared
236 SkString p2; // difference in radii (r1 - r0) 236 SkString p2; // difference in radii (r1 - r0)
237 237
238 builder->getUniformVariable(fParamUni).appendArrayAccess(0, &p0); 238 builder->getUniformVariable(fParamUni).appendArrayAccess(0, &p0);
239 builder->getUniformVariable(fParamUni).appendArrayAccess(1, &p1); 239 builder->getUniformVariable(fParamUni).appendArrayAccess(1, &p1);
240 builder->getUniformVariable(fParamUni).appendArrayAccess(2, &p2); 240 builder->getUniformVariable(fParamUni).appendArrayAccess(2, &p2);
241 241
242 // We interpolate the linear component in coords[1]. 242 // We interpolate the linear component in coords[1].
243 SkASSERT(coords[0].type() == coords[1].type()); 243 SkASSERT(coords[0].type() == coords[1].type());
244 const char* coords2D; 244 const char* coords2D;
245 SkString bVar; 245 SkString bVar;
246 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); 246 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
247 if (kVec3f_GrSLType == coords[0].type()) { 247 if (kVec3f_GrSLType == coords[0].type()) {
248 fsBuilder->codeAppendf("\tvec3 interpolants = vec3(%s.xy / %s.z, %s.x / %s.z);\n", 248 fsBuilder->codeAppendf("\tvec3 interpolants = vec3(%s.xy / %s.z, %s.x / %s.z);\n",
249 coords[0].c_str(), coords[0].c_str(), coords[1].c _str(), coords[1].c_str()); 249 coords[0].c_str(), coords[0].c_str(), coords[1].c _str(),
250 coords[1].c_str());
250 coords2D = "interpolants.xy"; 251 coords2D = "interpolants.xy";
251 bVar = "interpolants.z"; 252 bVar = "interpolants.z";
252 } else { 253 } else {
253 coords2D = coords[0].c_str(); 254 coords2D = coords[0].c_str();
254 bVar.printf("%s.x", coords[1].c_str()); 255 bVar.printf("%s.x", coords[1].c_str());
255 } 256 }
256 257
257 // output will default to transparent black (we simply won't write anything 258 // output will default to transparent black (we simply won't write anything
258 // else to it if invalid, instead of discarding or returning prematurely) 259 // else to it if invalid, instead of discarding or returning prematurely)
259 fsBuilder->codeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", outputColor); 260 fsBuilder->codeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", outputColor);
260 261
261 // c = (x^2)+(y^2) - params[1] 262 // c = (x^2)+(y^2) - params[1]
262 fsBuilder->codeAppendf("\tfloat %s = dot(%s, %s) - %s;\n", 263 fsBuilder->codeAppendf("\tfloat %s = dot(%s, %s) - %s;\n",
263 cName.c_str(), coords2D, coords2D, p1.c_str()); 264 cName.c_str(), coords2D, coords2D, p1.c_str());
264 265
265 // linear case: t = -c/b 266 // linear case: t = -c/b
266 fsBuilder->codeAppendf("\tfloat %s = -(%s / %s);\n", tName.c_str(), 267 fsBuilder->codeAppendf("\tfloat %s = -(%s / %s);\n", tName.c_str(),
267 cName.c_str(), bVar.c_str()); 268 cName.c_str(), bVar.c_str());
268 269
269 // if r(t) > 0, then t will be the x coordinate 270 // if r(t) > 0, then t will be the x coordinate
270 fsBuilder->codeAppendf("\tif (%s * %s + %s > 0.0) {\n", tName.c_str(), 271 fsBuilder->codeAppendf("\tif (%s * %s + %s > 0.0) {\n", tName.c_str(),
271 p2.c_str(), p0.c_str()); 272 p2.c_str(), p0.c_str());
272 fsBuilder->codeAppend("\t"); 273 fsBuilder->codeAppend("\t");
273 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa mplers); 274 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa mplers);
274 fsBuilder->codeAppend("\t}\n"); 275 fsBuilder->codeAppend("\t}\n");
275 } 276 }
276 277
277 void GLEdge2PtConicalEffect::setData(const GrGLProgramDataManager& pdman, 278 void GLEdge2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
278 const GrDrawEffect& drawEffect) { 279 const GrEffect& effect) {
279 INHERITED::setData(pdman, drawEffect); 280 INHERITED::setData(pdman, effect);
280 const Edge2PtConicalEffect& data = drawEffect.castEffect<Edge2PtConicalEffec t>(); 281 const Edge2PtConicalEffect& data = effect.cast<Edge2PtConicalEffect>();
281 SkScalar radius0 = data.radius(); 282 SkScalar radius0 = data.radius();
282 SkScalar diffRadius = data.diffRadius(); 283 SkScalar diffRadius = data.diffRadius();
283 284
284 if (fCachedRadius != radius0 || 285 if (fCachedRadius != radius0 ||
285 fCachedDiffRadius != diffRadius) { 286 fCachedDiffRadius != diffRadius) {
286 287
287 float values[3] = { 288 float values[3] = {
288 SkScalarToFloat(radius0), 289 SkScalarToFloat(radius0),
289 SkScalarToFloat(SkScalarMul(radius0, radius0)), 290 SkScalarToFloat(SkScalarMul(radius0, radius0)),
290 SkScalarToFloat(diffRadius) 291 SkScalarToFloat(diffRadius)
291 }; 292 };
292 293
293 pdman.set1fv(fParamUni, 3, values); 294 pdman.set1fv(fParamUni, 3, values);
294 fCachedRadius = radius0; 295 fCachedRadius = radius0;
295 fCachedDiffRadius = diffRadius; 296 fCachedDiffRadius = diffRadius;
296 } 297 }
297 } 298 }
298 299
299 void GLEdge2PtConicalEffect::GenKey(const GrDrawEffect& drawEffect, 300 void GLEdge2PtConicalEffect::GenKey(const GrEffect& effect,
300 const GrGLCaps&, GrEffectKeyBuilder* b) { 301 const GrGLCaps&, GrEffectKeyBuilder* b) {
301 b->add32(GenBaseGradientKey(drawEffect)); 302 b->add32(GenBaseGradientKey(effect));
302 } 303 }
303 304
304 ////////////////////////////////////////////////////////////////////////////// 305 //////////////////////////////////////////////////////////////////////////////
305 // Focal Conical Gradients 306 // Focal Conical Gradients
306 ////////////////////////////////////////////////////////////////////////////// 307 //////////////////////////////////////////////////////////////////////////////
307 308
308 static ConicalType set_matrix_focal_conical(const SkTwoPointConicalGradient& sha der, 309 static ConicalType set_matrix_focal_conical(const SkTwoPointConicalGradient& sha der,
309 SkMatrix* invLMatrix, SkScalar* foca lX) { 310 SkMatrix* invLMatrix, SkScalar* foca lX) {
310 // Inverse of the current local matrix is passed in then, 311 // Inverse of the current local matrix is passed in then,
311 // translate, scale, and rotate such that endCircle is unit circle on x-axis , 312 // translate, scale, and rotate such that endCircle is unit circle on x-axis ,
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after
381 static const char* Name() { return "Two-Point Conical Gradient Focal Outside "; } 382 static const char* Name() { return "Two-Point Conical Gradient Focal Outside "; }
382 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE; 383 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
383 384
384 bool isFlipped() const { return fIsFlipped; } 385 bool isFlipped() const { return fIsFlipped; }
385 SkScalar focal() const { return fFocalX; } 386 SkScalar focal() const { return fFocalX; }
386 387
387 typedef GLFocalOutside2PtConicalEffect GLEffect; 388 typedef GLFocalOutside2PtConicalEffect GLEffect;
388 389
389 private: 390 private:
390 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE { 391 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
391 const FocalOutside2PtConicalEffect& s = CastEffect<FocalOutside2PtConica lEffect>(sBase); 392 const FocalOutside2PtConicalEffect& s = sBase.cast<FocalOutside2PtConica lEffect>();
392 return (INHERITED::onIsEqual(sBase) && 393 return (INHERITED::onIsEqual(sBase) &&
393 this->fFocalX == s.fFocalX && 394 this->fFocalX == s.fFocalX &&
394 this->fIsFlipped == s.fIsFlipped); 395 this->fIsFlipped == s.fIsFlipped);
395 } 396 }
396 397
397 FocalOutside2PtConicalEffect(GrContext* ctx, 398 FocalOutside2PtConicalEffect(GrContext* ctx,
398 const SkTwoPointConicalGradient& shader, 399 const SkTwoPointConicalGradient& shader,
399 const SkMatrix& matrix, 400 const SkMatrix& matrix,
400 SkShader::TileMode tm, 401 SkShader::TileMode tm,
401 SkScalar focalX) 402 SkScalar focalX)
402 : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX), fIsFlipped(shader.isF lippedGrad()) {} 403 : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX), fIsFlipped(shader.isF lippedGrad()) {}
403 404
404 GR_DECLARE_EFFECT_TEST; 405 GR_DECLARE_EFFECT_TEST;
405 406
406 SkScalar fFocalX; 407 SkScalar fFocalX;
407 bool fIsFlipped; 408 bool fIsFlipped;
408 409
409 typedef GrGradientEffect INHERITED; 410 typedef GrGradientEffect INHERITED;
410 }; 411 };
411 412
412 class GLFocalOutside2PtConicalEffect : public GrGLGradientEffect { 413 class GLFocalOutside2PtConicalEffect : public GrGLGradientEffect {
413 public: 414 public:
414 GLFocalOutside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&); 415 GLFocalOutside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect&);
415 virtual ~GLFocalOutside2PtConicalEffect() { } 416 virtual ~GLFocalOutside2PtConicalEffect() { }
416 417
417 virtual void emitCode(GrGLProgramBuilder*, 418 virtual void emitCode(GrGLProgramBuilder*,
418 const GrDrawEffect&, 419 const GrEffect&,
419 const GrEffectKey&, 420 const GrEffectKey&,
420 const char* outputColor, 421 const char* outputColor,
421 const char* inputColor, 422 const char* inputColor,
422 const TransformedCoordsArray&, 423 const TransformedCoordsArray&,
423 const TextureSamplerArray&) SK_OVERRIDE; 424 const TextureSamplerArray&) SK_OVERRIDE;
424 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_ OVERRIDE; 425 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER RIDE;
425 426
426 static void GenKey(const GrDrawEffect&, const GrGLCaps& caps, GrEffectKeyBui lder* b); 427 static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder * b);
427 428
428 protected: 429 protected:
429 UniformHandle fParamUni; 430 UniformHandle fParamUni;
430 431
431 const char* fVSVaryingName; 432 const char* fVSVaryingName;
432 const char* fFSVaryingName; 433 const char* fFSVaryingName;
433 434
434 bool fIsFlipped; 435 bool fIsFlipped;
435 436
436 // @{ 437 // @{
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after
478 colors , stops, colorCount, 479 colors , stops, colorCount,
479 tm)); 480 tm));
480 SkPaint paint; 481 SkPaint paint;
481 GrEffect* effect; 482 GrEffect* effect;
482 GrColor paintColor; 483 GrColor paintColor;
483 SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effec t)); 484 SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effec t));
484 return effect; 485 return effect;
485 } 486 }
486 487
487 GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrBackendEf fectFactory& factory, 488 GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrBackendEf fectFactory& factory,
488 const GrDrawEffec t& drawEffect) 489 const GrEffect& e ffect)
489 : INHERITED(factory) 490 : INHERITED(factory)
490 , fVSVaryingName(NULL) 491 , fVSVaryingName(NULL)
491 , fFSVaryingName(NULL) 492 , fFSVaryingName(NULL)
492 , fCachedFocal(SK_ScalarMax) { 493 , fCachedFocal(SK_ScalarMax) {
493 const FocalOutside2PtConicalEffect& data = drawEffect.castEffect<FocalOutsid e2PtConicalEffect>(); 494 const FocalOutside2PtConicalEffect& data = effect.cast<FocalOutside2PtConica lEffect>();
494 fIsFlipped = data.isFlipped(); 495 fIsFlipped = data.isFlipped();
495 } 496 }
496 497
497 void GLFocalOutside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder, 498 void GLFocalOutside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,
498 const GrDrawEffect&, 499 const GrEffect&,
499 const GrEffectKey& key, 500 const GrEffectKey& key,
500 const char* outputColor, 501 const char* outputColor,
501 const char* inputColor, 502 const char* inputColor,
502 const TransformedCoordsArray& coor ds, 503 const TransformedCoordsArray& coor ds,
503 const TextureSamplerArray& sampler s) { 504 const TextureSamplerArray& sampler s) {
504 uint32_t baseKey = key.get32(0); 505 uint32_t baseKey = key.get32(0);
505 this->emitUniforms(builder, baseKey); 506 this->emitUniforms(builder, baseKey);
506 fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibilit y, 507 fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibilit y,
507 kFloat_GrSLType, "Conical2FSParams", 2) ; 508 kFloat_GrSLType, "Conical2FSParams", 2) ;
508 SkString tName("t"); 509 SkString tName("t");
(...skipping 28 matching lines...) Expand all
537 coords2D, p0.c_str()); 538 coords2D, p0.c_str());
538 } 539 }
539 540
540 fsBuilder->codeAppendf("\tif (%s >= 0.0 && d >= 0.0) {\n", tName.c_str()); 541 fsBuilder->codeAppendf("\tif (%s >= 0.0 && d >= 0.0) {\n", tName.c_str());
541 fsBuilder->codeAppend("\t\t"); 542 fsBuilder->codeAppend("\t\t");
542 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa mplers); 543 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa mplers);
543 fsBuilder->codeAppend("\t}\n"); 544 fsBuilder->codeAppend("\t}\n");
544 } 545 }
545 546
546 void GLFocalOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman , 547 void GLFocalOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman ,
547 const GrDrawEffect& drawEffect) { 548 const GrEffect& effect) {
548 INHERITED::setData(pdman, drawEffect); 549 INHERITED::setData(pdman, effect);
549 const FocalOutside2PtConicalEffect& data = drawEffect.castEffect<FocalOutsid e2PtConicalEffect>(); 550 const FocalOutside2PtConicalEffect& data = effect.cast<FocalOutside2PtConica lEffect>();
550 SkASSERT(data.isFlipped() == fIsFlipped); 551 SkASSERT(data.isFlipped() == fIsFlipped);
551 SkScalar focal = data.focal(); 552 SkScalar focal = data.focal();
552 553
553 if (fCachedFocal != focal) { 554 if (fCachedFocal != focal) {
554 SkScalar oneMinus2F = 1.f - SkScalarMul(focal, focal); 555 SkScalar oneMinus2F = 1.f - SkScalarMul(focal, focal);
555 556
556 float values[2] = { 557 float values[2] = {
557 SkScalarToFloat(focal), 558 SkScalarToFloat(focal),
558 SkScalarToFloat(oneMinus2F), 559 SkScalarToFloat(oneMinus2F),
559 }; 560 };
560 561
561 pdman.set1fv(fParamUni, 2, values); 562 pdman.set1fv(fParamUni, 2, values);
562 fCachedFocal = focal; 563 fCachedFocal = focal;
563 } 564 }
564 } 565 }
565 566
566 void GLFocalOutside2PtConicalEffect::GenKey(const GrDrawEffect& drawEffect, 567 void GLFocalOutside2PtConicalEffect::GenKey(const GrEffect& effect,
567 const GrGLCaps&, GrEffectKeyBuilder* b) { 568 const GrGLCaps&, GrEffectKeyBuilder* b) {
568 uint32_t* key = b->add32n(2); 569 uint32_t* key = b->add32n(2);
569 key[0] = GenBaseGradientKey(drawEffect); 570 key[0] = GenBaseGradientKey(effect);
570 key[1] = drawEffect.castEffect<FocalOutside2PtConicalEffect>().isFlipped(); 571 key[1] = effect.cast<FocalOutside2PtConicalEffect>().isFlipped();
571 } 572 }
572 573
573 ////////////////////////////////////////////////////////////////////////////// 574 //////////////////////////////////////////////////////////////////////////////
574 575
575 class GLFocalInside2PtConicalEffect; 576 class GLFocalInside2PtConicalEffect;
576 577
577 class FocalInside2PtConicalEffect : public GrGradientEffect { 578 class FocalInside2PtConicalEffect : public GrGradientEffect {
578 public: 579 public:
579 580
580 static GrEffect* Create(GrContext* ctx, 581 static GrEffect* Create(GrContext* ctx,
581 const SkTwoPointConicalGradient& shader, 582 const SkTwoPointConicalGradient& shader,
582 const SkMatrix& matrix, 583 const SkMatrix& matrix,
583 SkShader::TileMode tm, 584 SkShader::TileMode tm,
584 SkScalar focalX) { 585 SkScalar focalX) {
585 return SkNEW_ARGS(FocalInside2PtConicalEffect, (ctx, shader, matrix, tm, focalX)); 586 return SkNEW_ARGS(FocalInside2PtConicalEffect, (ctx, shader, matrix, tm, focalX));
586 } 587 }
587 588
588 virtual ~FocalInside2PtConicalEffect() {} 589 virtual ~FocalInside2PtConicalEffect() {}
589 590
590 static const char* Name() { return "Two-Point Conical Gradient Focal Inside" ; } 591 static const char* Name() { return "Two-Point Conical Gradient Focal Inside" ; }
591 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE; 592 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
592 593
593 SkScalar focal() const { return fFocalX; } 594 SkScalar focal() const { return fFocalX; }
594 595
595 typedef GLFocalInside2PtConicalEffect GLEffect; 596 typedef GLFocalInside2PtConicalEffect GLEffect;
596 597
597 private: 598 private:
598 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE { 599 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
599 const FocalInside2PtConicalEffect& s = CastEffect<FocalInside2PtConicalE ffect>(sBase); 600 const FocalInside2PtConicalEffect& s = sBase.cast<FocalInside2PtConicalE ffect>();
600 return (INHERITED::onIsEqual(sBase) && 601 return (INHERITED::onIsEqual(sBase) &&
601 this->fFocalX == s.fFocalX); 602 this->fFocalX == s.fFocalX);
602 } 603 }
603 604
604 FocalInside2PtConicalEffect(GrContext* ctx, 605 FocalInside2PtConicalEffect(GrContext* ctx,
605 const SkTwoPointConicalGradient& shader, 606 const SkTwoPointConicalGradient& shader,
606 const SkMatrix& matrix, 607 const SkMatrix& matrix,
607 SkShader::TileMode tm, 608 SkShader::TileMode tm,
608 SkScalar focalX) 609 SkScalar focalX)
609 : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX) {} 610 : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX) {}
610 611
611 GR_DECLARE_EFFECT_TEST; 612 GR_DECLARE_EFFECT_TEST;
612 613
613 SkScalar fFocalX; 614 SkScalar fFocalX;
614 615
615 typedef GrGradientEffect INHERITED; 616 typedef GrGradientEffect INHERITED;
616 }; 617 };
617 618
618 class GLFocalInside2PtConicalEffect : public GrGLGradientEffect { 619 class GLFocalInside2PtConicalEffect : public GrGLGradientEffect {
619 public: 620 public:
620 GLFocalInside2PtConicalEffect(const GrBackendEffectFactory& factory, const G rDrawEffect&); 621 GLFocalInside2PtConicalEffect(const GrBackendEffectFactory& factory, const G rEffect&);
621 virtual ~GLFocalInside2PtConicalEffect() {} 622 virtual ~GLFocalInside2PtConicalEffect() {}
622 623
623 virtual void emitCode(GrGLProgramBuilder*, 624 virtual void emitCode(GrGLProgramBuilder*,
624 const GrDrawEffect&, 625 const GrEffect&,
625 const GrEffectKey&, 626 const GrEffectKey&,
626 const char* outputColor, 627 const char* outputColor,
627 const char* inputColor, 628 const char* inputColor,
628 const TransformedCoordsArray&, 629 const TransformedCoordsArray&,
629 const TextureSamplerArray&) SK_OVERRIDE; 630 const TextureSamplerArray&) SK_OVERRIDE;
630 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_ OVERRIDE; 631 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER RIDE;
631 632
632 static void GenKey(const GrDrawEffect&, const GrGLCaps& caps, GrEffectKeyBui lder* b); 633 static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder * b);
633 634
634 protected: 635 protected:
635 UniformHandle fFocalUni; 636 UniformHandle fFocalUni;
636 637
637 const char* fVSVaryingName; 638 const char* fVSVaryingName;
638 const char* fFSVaryingName; 639 const char* fFSVaryingName;
639 640
640 // @{ 641 // @{
641 /// Values last uploaded as uniforms 642 /// Values last uploaded as uniforms
642 643
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after
684 colors , stops, colorCount, 685 colors , stops, colorCount,
685 tm)); 686 tm));
686 SkPaint paint; 687 SkPaint paint;
687 GrColor paintColor; 688 GrColor paintColor;
688 GrEffect* effect; 689 GrEffect* effect;
689 SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effec t)); 690 SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effec t));
690 return effect; 691 return effect;
691 } 692 }
692 693
693 GLFocalInside2PtConicalEffect::GLFocalInside2PtConicalEffect(const GrBackendEffe ctFactory& factory, 694 GLFocalInside2PtConicalEffect::GLFocalInside2PtConicalEffect(const GrBackendEffe ctFactory& factory,
694 const GrDrawEffect& drawEffect) 695 const GrEffect& eff ect)
695 : INHERITED(factory) 696 : INHERITED(factory)
696 , fVSVaryingName(NULL) 697 , fVSVaryingName(NULL)
697 , fFSVaryingName(NULL) 698 , fFSVaryingName(NULL)
698 , fCachedFocal(SK_ScalarMax) {} 699 , fCachedFocal(SK_ScalarMax) {}
699 700
700 void GLFocalInside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder, 701 void GLFocalInside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,
701 const GrDrawEffect&, 702 const GrEffect&,
702 const GrEffectKey& key, 703 const GrEffectKey& key,
703 const char* outputColor, 704 const char* outputColor,
704 const char* inputColor, 705 const char* inputColor,
705 const TransformedCoordsArray& coord s, 706 const TransformedCoordsArray& coord s,
706 const TextureSamplerArray& samplers ) { 707 const TextureSamplerArray& samplers ) {
707 uint32_t baseKey = key.get32(0); 708 uint32_t baseKey = key.get32(0);
708 this->emitUniforms(builder, baseKey); 709 this->emitUniforms(builder, baseKey);
709 fFocalUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 710 fFocalUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
710 kFloat_GrSLType, "Conical2FSParams"); 711 kFloat_GrSLType, "Conical2FSParams");
711 SkString tName("t"); 712 SkString tName("t");
712 713
713 // this is the distance along x-axis from the end center to focal point in 714 // this is the distance along x-axis from the end center to focal point in
714 // transformed coordinates 715 // transformed coordinates
715 GrGLShaderVar focal = builder->getUniformVariable(fFocalUni); 716 GrGLShaderVar focal = builder->getUniformVariable(fFocalUni);
716 717
717 // if we have a vec3 from being in perspective, convert it to a vec2 first 718 // if we have a vec3 from being in perspective, convert it to a vec2 first
718 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); 719 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
719 SkString coords2DString = fsBuilder->ensureFSCoords2D(coords, 0); 720 SkString coords2DString = fsBuilder->ensureFSCoords2D(coords, 0);
720 const char* coords2D = coords2DString.c_str(); 721 const char* coords2D = coords2DString.c_str();
721 722
722 // t = p.x * focalX + length(p) 723 // t = p.x * focalX + length(p)
723 fsBuilder->codeAppendf("\tfloat %s = %s.x * %s + length(%s);\n", tName.c_st r(), 724 fsBuilder->codeAppendf("\tfloat %s = %s.x * %s + length(%s);\n", tName.c_st r(),
724 coords2D, focal.c_str(), coords2D); 725 coords2D, focal.c_str(), coords2D);
725 726
726 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa mplers); 727 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa mplers);
727 } 728 }
728 729
729 void GLFocalInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman, 730 void GLFocalInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
730 const GrDrawEffect& drawEffect) { 731 const GrEffect& effect) {
731 INHERITED::setData(pdman, drawEffect); 732 INHERITED::setData(pdman, effect);
732 const FocalInside2PtConicalEffect& data = drawEffect.castEffect<FocalInside2 PtConicalEffect>(); 733 const FocalInside2PtConicalEffect& data = effect.cast<FocalInside2PtConicalE ffect>();
733 SkScalar focal = data.focal(); 734 SkScalar focal = data.focal();
734 735
735 if (fCachedFocal != focal) { 736 if (fCachedFocal != focal) {
736 pdman.set1f(fFocalUni, SkScalarToFloat(focal)); 737 pdman.set1f(fFocalUni, SkScalarToFloat(focal));
737 fCachedFocal = focal; 738 fCachedFocal = focal;
738 } 739 }
739 } 740 }
740 741
741 void GLFocalInside2PtConicalEffect::GenKey(const GrDrawEffect& drawEffect, 742 void GLFocalInside2PtConicalEffect::GenKey(const GrEffect& effect,
742 const GrGLCaps&, GrEffectKeyBuilder* b) { 743 const GrGLCaps&, GrEffectKeyBuilder* b) {
743 b->add32(GenBaseGradientKey(drawEffect)); 744 b->add32(GenBaseGradientKey(effect));
744 } 745 }
745 746
746 ////////////////////////////////////////////////////////////////////////////// 747 //////////////////////////////////////////////////////////////////////////////
747 // Circle Conical Gradients 748 // Circle Conical Gradients
748 ////////////////////////////////////////////////////////////////////////////// 749 //////////////////////////////////////////////////////////////////////////////
749 750
750 struct CircleConicalInfo { 751 struct CircleConicalInfo {
751 SkPoint fCenterEnd; 752 SkPoint fCenterEnd;
752 SkScalar fA; 753 SkScalar fA;
753 SkScalar fB; 754 SkScalar fB;
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after
828 SkScalar centerX() const { return fInfo.fCenterEnd.fX; } 829 SkScalar centerX() const { return fInfo.fCenterEnd.fX; }
829 SkScalar centerY() const { return fInfo.fCenterEnd.fY; } 830 SkScalar centerY() const { return fInfo.fCenterEnd.fY; }
830 SkScalar A() const { return fInfo.fA; } 831 SkScalar A() const { return fInfo.fA; }
831 SkScalar B() const { return fInfo.fB; } 832 SkScalar B() const { return fInfo.fB; }
832 SkScalar C() const { return fInfo.fC; } 833 SkScalar C() const { return fInfo.fC; }
833 834
834 typedef GLCircleInside2PtConicalEffect GLEffect; 835 typedef GLCircleInside2PtConicalEffect GLEffect;
835 836
836 private: 837 private:
837 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE { 838 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
838 const CircleInside2PtConicalEffect& s = CastEffect<CircleInside2PtConica lEffect>(sBase); 839 const CircleInside2PtConicalEffect& s = sBase.cast<CircleInside2PtConica lEffect>();
839 return (INHERITED::onIsEqual(sBase) && 840 return (INHERITED::onIsEqual(sBase) &&
840 this->fInfo.fCenterEnd == s.fInfo.fCenterEnd && 841 this->fInfo.fCenterEnd == s.fInfo.fCenterEnd &&
841 this->fInfo.fA == s.fInfo.fA && 842 this->fInfo.fA == s.fInfo.fA &&
842 this->fInfo.fB == s.fInfo.fB && 843 this->fInfo.fB == s.fInfo.fB &&
843 this->fInfo.fC == s.fInfo.fC); 844 this->fInfo.fC == s.fInfo.fC);
844 } 845 }
845 846
846 CircleInside2PtConicalEffect(GrContext* ctx, 847 CircleInside2PtConicalEffect(GrContext* ctx,
847 const SkTwoPointConicalGradient& shader, 848 const SkTwoPointConicalGradient& shader,
848 const SkMatrix& matrix, 849 const SkMatrix& matrix,
849 SkShader::TileMode tm, 850 SkShader::TileMode tm,
850 const CircleConicalInfo& info) 851 const CircleConicalInfo& info)
851 : INHERITED(ctx, shader, matrix, tm), fInfo(info) {} 852 : INHERITED(ctx, shader, matrix, tm), fInfo(info) {}
852 853
853 GR_DECLARE_EFFECT_TEST; 854 GR_DECLARE_EFFECT_TEST;
854 855
855 const CircleConicalInfo fInfo; 856 const CircleConicalInfo fInfo;
856 857
857 typedef GrGradientEffect INHERITED; 858 typedef GrGradientEffect INHERITED;
858 }; 859 };
859 860
860 class GLCircleInside2PtConicalEffect : public GrGLGradientEffect { 861 class GLCircleInside2PtConicalEffect : public GrGLGradientEffect {
861 public: 862 public:
862 GLCircleInside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&); 863 GLCircleInside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect&);
863 virtual ~GLCircleInside2PtConicalEffect() {} 864 virtual ~GLCircleInside2PtConicalEffect() {}
864 865
865 virtual void emitCode(GrGLProgramBuilder*, 866 virtual void emitCode(GrGLProgramBuilder*,
866 const GrDrawEffect&, 867 const GrEffect&,
867 const GrEffectKey&, 868 const GrEffectKey&,
868 const char* outputColor, 869 const char* outputColor,
869 const char* inputColor, 870 const char* inputColor,
870 const TransformedCoordsArray&, 871 const TransformedCoordsArray&,
871 const TextureSamplerArray&) SK_OVERRIDE; 872 const TextureSamplerArray&) SK_OVERRIDE;
872 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_ OVERRIDE; 873 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER RIDE;
873 874
874 static void GenKey(const GrDrawEffect&, const GrGLCaps& caps, GrEffectKeyBui lder* b); 875 static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder * b);
875 876
876 protected: 877 protected:
877 UniformHandle fCenterUni; 878 UniformHandle fCenterUni;
878 UniformHandle fParamUni; 879 UniformHandle fParamUni;
879 880
880 const char* fVSVaryingName; 881 const char* fVSVaryingName;
881 const char* fFSVaryingName; 882 const char* fFSVaryingName;
882 883
883 // @{ 884 // @{
884 /// Values last uploaded as uniforms 885 /// Values last uploaded as uniforms
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after
930 colors , stops, colorCount, 931 colors , stops, colorCount,
931 tm)); 932 tm));
932 SkPaint paint; 933 SkPaint paint;
933 GrColor paintColor; 934 GrColor paintColor;
934 GrEffect* effect; 935 GrEffect* effect;
935 SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effec t)); 936 SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effec t));
936 return effect; 937 return effect;
937 } 938 }
938 939
939 GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrBackendEf fectFactory& factory, 940 GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrBackendEf fectFactory& factory,
940 const GrDrawEffec t& drawEffect) 941 const GrEffect& e ffect)
941 : INHERITED(factory) 942 : INHERITED(factory)
942 , fVSVaryingName(NULL) 943 , fVSVaryingName(NULL)
943 , fFSVaryingName(NULL) 944 , fFSVaryingName(NULL)
944 , fCachedCenterX(SK_ScalarMax) 945 , fCachedCenterX(SK_ScalarMax)
945 , fCachedCenterY(SK_ScalarMax) 946 , fCachedCenterY(SK_ScalarMax)
946 , fCachedA(SK_ScalarMax) 947 , fCachedA(SK_ScalarMax)
947 , fCachedB(SK_ScalarMax) 948 , fCachedB(SK_ScalarMax)
948 , fCachedC(SK_ScalarMax) {} 949 , fCachedC(SK_ScalarMax) {}
949 950
950 void GLCircleInside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder, 951 void GLCircleInside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,
951 const GrDrawEffect&, 952 const GrEffect&,
952 const GrEffectKey& key, 953 const GrEffectKey& key,
953 const char* outputColor, 954 const char* outputColor,
954 const char* inputColor, 955 const char* inputColor,
955 const TransformedCoordsArray& coor ds, 956 const TransformedCoordsArray& coor ds,
956 const TextureSamplerArray& sampler s) { 957 const TextureSamplerArray& sampler s) {
957 uint32_t baseKey = key.get32(0); 958 uint32_t baseKey = key.get32(0);
958 this->emitUniforms(builder, baseKey); 959 this->emitUniforms(builder, baseKey);
959 fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 960 fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
960 kVec2f_GrSLType, "Conical2FSCenter"); 961 kVec2f_GrSLType, "Conical2FSCenter");
961 fParamUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 962 fParamUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
(...skipping 13 matching lines...) Expand all
975 976
976 // p = coords2D 977 // p = coords2D
977 // e = center end 978 // e = center end
978 // r = radius end 979 // r = radius end
979 // A = dot(e, e) - r^2 + 2 * r - 1 980 // A = dot(e, e) - r^2 + 2 * r - 1
980 // B = (r -1) / A 981 // B = (r -1) / A
981 // C = 1 / A 982 // C = 1 / A
982 // d = dot(e, p) + B 983 // d = dot(e, p) + B
983 // t = d +/- sqrt(d^2 - A * dot(p, p) + C) 984 // t = d +/- sqrt(d^2 - A * dot(p, p) + C)
984 fsBuilder->codeAppendf("\tfloat pDotp = dot(%s, %s);\n", coords2D, coords2D ); 985 fsBuilder->codeAppendf("\tfloat pDotp = dot(%s, %s);\n", coords2D, coords2D );
985 fsBuilder->codeAppendf("\tfloat d = dot(%s, %s) + %s.y;\n", coords2D, cente r.c_str(), params.c_str()); 986 fsBuilder->codeAppendf("\tfloat d = dot(%s, %s) + %s.y;\n", coords2D, cente r.c_str(),
987 params.c_str());
986 fsBuilder->codeAppendf("\tfloat %s = d + sqrt(d * d - %s.x * pDotp + %s.z);\ n", 988 fsBuilder->codeAppendf("\tfloat %s = d + sqrt(d * d - %s.x * pDotp + %s.z);\ n",
987 tName.c_str(), params.c_str(), params.c_str()); 989 tName.c_str(), params.c_str(), params.c_str());
988 990
989 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa mplers); 991 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa mplers);
990 } 992 }
991 993
992 void GLCircleInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman , 994 void GLCircleInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman ,
993 const GrDrawEffect& drawEffect) { 995 const GrEffect& effect) {
994 INHERITED::setData(pdman, drawEffect); 996 INHERITED::setData(pdman, effect);
995 const CircleInside2PtConicalEffect& data = drawEffect.castEffect<CircleInsid e2PtConicalEffect>(); 997 const CircleInside2PtConicalEffect& data = effect.cast<CircleInside2PtConica lEffect>();
996 SkScalar centerX = data.centerX(); 998 SkScalar centerX = data.centerX();
997 SkScalar centerY = data.centerY(); 999 SkScalar centerY = data.centerY();
998 SkScalar A = data.A(); 1000 SkScalar A = data.A();
999 SkScalar B = data.B(); 1001 SkScalar B = data.B();
1000 SkScalar C = data.C(); 1002 SkScalar C = data.C();
1001 1003
1002 if (fCachedCenterX != centerX || fCachedCenterY != centerY || 1004 if (fCachedCenterX != centerX || fCachedCenterY != centerY ||
1003 fCachedA != A || fCachedB != B || fCachedC != C) { 1005 fCachedA != A || fCachedB != B || fCachedC != C) {
1004 1006
1005 pdman.set2f(fCenterUni, SkScalarToFloat(centerX), SkScalarToFloat(center Y)); 1007 pdman.set2f(fCenterUni, SkScalarToFloat(centerX), SkScalarToFloat(center Y));
1006 pdman.set3f(fParamUni, SkScalarToFloat(A), SkScalarToFloat(B), SkScalarT oFloat(C)); 1008 pdman.set3f(fParamUni, SkScalarToFloat(A), SkScalarToFloat(B), SkScalarT oFloat(C));
1007 1009
1008 fCachedCenterX = centerX; 1010 fCachedCenterX = centerX;
1009 fCachedCenterY = centerY; 1011 fCachedCenterY = centerY;
1010 fCachedA = A; 1012 fCachedA = A;
1011 fCachedB = B; 1013 fCachedB = B;
1012 fCachedC = C; 1014 fCachedC = C;
1013 } 1015 }
1014 } 1016 }
1015 1017
1016 void GLCircleInside2PtConicalEffect::GenKey(const GrDrawEffect& drawEffect, 1018 void GLCircleInside2PtConicalEffect::GenKey(const GrEffect& effect,
1017 const GrGLCaps&, GrEffectKeyBuilder* b) { 1019 const GrGLCaps&, GrEffectKeyBuilder* b) {
1018 b->add32(GenBaseGradientKey(drawEffect)); 1020 b->add32(GenBaseGradientKey(effect));
1019 } 1021 }
1020 1022
1021 ////////////////////////////////////////////////////////////////////////////// 1023 //////////////////////////////////////////////////////////////////////////////
1022 1024
1023 class GLCircleOutside2PtConicalEffect; 1025 class GLCircleOutside2PtConicalEffect;
1024 1026
1025 class CircleOutside2PtConicalEffect : public GrGradientEffect { 1027 class CircleOutside2PtConicalEffect : public GrGradientEffect {
1026 public: 1028 public:
1027 1029
1028 static GrEffect* Create(GrContext* ctx, 1030 static GrEffect* Create(GrContext* ctx,
(...skipping 14 matching lines...) Expand all
1043 SkScalar A() const { return fInfo.fA; } 1045 SkScalar A() const { return fInfo.fA; }
1044 SkScalar B() const { return fInfo.fB; } 1046 SkScalar B() const { return fInfo.fB; }
1045 SkScalar C() const { return fInfo.fC; } 1047 SkScalar C() const { return fInfo.fC; }
1046 SkScalar tLimit() const { return fTLimit; } 1048 SkScalar tLimit() const { return fTLimit; }
1047 bool isFlipped() const { return fIsFlipped; } 1049 bool isFlipped() const { return fIsFlipped; }
1048 1050
1049 typedef GLCircleOutside2PtConicalEffect GLEffect; 1051 typedef GLCircleOutside2PtConicalEffect GLEffect;
1050 1052
1051 private: 1053 private:
1052 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE { 1054 virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
1053 const CircleOutside2PtConicalEffect& s = CastEffect<CircleOutside2PtConi calEffect>(sBase); 1055 const CircleOutside2PtConicalEffect& s = sBase.cast<CircleOutside2PtConi calEffect>();
1054 return (INHERITED::onIsEqual(sBase) && 1056 return (INHERITED::onIsEqual(sBase) &&
1055 this->fInfo.fCenterEnd == s.fInfo.fCenterEnd && 1057 this->fInfo.fCenterEnd == s.fInfo.fCenterEnd &&
1056 this->fInfo.fA == s.fInfo.fA && 1058 this->fInfo.fA == s.fInfo.fA &&
1057 this->fInfo.fB == s.fInfo.fB && 1059 this->fInfo.fB == s.fInfo.fB &&
1058 this->fInfo.fC == s.fInfo.fC && 1060 this->fInfo.fC == s.fInfo.fC &&
1059 this->fTLimit == s.fTLimit && 1061 this->fTLimit == s.fTLimit &&
1060 this->fIsFlipped == s.fIsFlipped); 1062 this->fIsFlipped == s.fIsFlipped);
1061 } 1063 }
1062 1064
1063 CircleOutside2PtConicalEffect(GrContext* ctx, 1065 CircleOutside2PtConicalEffect(GrContext* ctx,
1064 const SkTwoPointConicalGradient& shader, 1066 const SkTwoPointConicalGradient& shader,
1065 const SkMatrix& matrix, 1067 const SkMatrix& matrix,
1066 SkShader::TileMode tm, 1068 SkShader::TileMode tm,
1067 const CircleConicalInfo& info) 1069 const CircleConicalInfo& info)
1068 : INHERITED(ctx, shader, matrix, tm), fInfo(info) { 1070 : INHERITED(ctx, shader, matrix, tm), fInfo(info) {
1069 if (shader.getStartRadius() != shader.getEndRadius()) { 1071 if (shader.getStartRadius() != shader.getEndRadius()) {
1070 fTLimit = SkScalarDiv(shader.getStartRadius(), (shader.getStartRadiu s() - shader.getEndRadius())); 1072 fTLimit = SkScalarDiv(shader.getStartRadius(),
1073 (shader.getStartRadius() - shader.getEndRadius ()));
1071 } else { 1074 } else {
1072 fTLimit = SK_ScalarMin; 1075 fTLimit = SK_ScalarMin;
1073 } 1076 }
1074 1077
1075 fIsFlipped = shader.isFlippedGrad(); 1078 fIsFlipped = shader.isFlippedGrad();
1076 } 1079 }
1077 1080
1078 GR_DECLARE_EFFECT_TEST; 1081 GR_DECLARE_EFFECT_TEST;
1079 1082
1080 const CircleConicalInfo fInfo; 1083 const CircleConicalInfo fInfo;
1081 SkScalar fTLimit; 1084 SkScalar fTLimit;
1082 bool fIsFlipped; 1085 bool fIsFlipped;
1083 1086
1084 typedef GrGradientEffect INHERITED; 1087 typedef GrGradientEffect INHERITED;
1085 }; 1088 };
1086 1089
1087 class GLCircleOutside2PtConicalEffect : public GrGLGradientEffect { 1090 class GLCircleOutside2PtConicalEffect : public GrGLGradientEffect {
1088 public: 1091 public:
1089 GLCircleOutside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&); 1092 GLCircleOutside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect&);
1090 virtual ~GLCircleOutside2PtConicalEffect() {} 1093 virtual ~GLCircleOutside2PtConicalEffect() {}
1091 1094
1092 virtual void emitCode(GrGLProgramBuilder*, 1095 virtual void emitCode(GrGLProgramBuilder*,
1093 const GrDrawEffect&, 1096 const GrEffect&,
1094 const GrEffectKey&, 1097 const GrEffectKey&,
1095 const char* outputColor, 1098 const char* outputColor,
1096 const char* inputColor, 1099 const char* inputColor,
1097 const TransformedCoordsArray&, 1100 const TransformedCoordsArray&,
1098 const TextureSamplerArray&) SK_OVERRIDE; 1101 const TextureSamplerArray&) SK_OVERRIDE;
1099 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_ OVERRIDE; 1102 virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVER RIDE;
1100 1103
1101 static void GenKey(const GrDrawEffect&, const GrGLCaps& caps, GrEffectKeyBui lder* b); 1104 static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder * b);
1102 1105
1103 protected: 1106 protected:
1104 UniformHandle fCenterUni; 1107 UniformHandle fCenterUni;
1105 UniformHandle fParamUni; 1108 UniformHandle fParamUni;
1106 1109
1107 const char* fVSVaryingName; 1110 const char* fVSVaryingName;
1108 const char* fFSVaryingName; 1111 const char* fFSVaryingName;
1109 1112
1110 bool fIsFlipped; 1113 bool fIsFlipped;
1111 1114
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after
1161 colors , stops, colorCount, 1164 colors , stops, colorCount,
1162 tm)); 1165 tm));
1163 SkPaint paint; 1166 SkPaint paint;
1164 GrColor paintColor; 1167 GrColor paintColor;
1165 GrEffect* effect; 1168 GrEffect* effect;
1166 SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effec t)); 1169 SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effec t));
1167 return effect; 1170 return effect;
1168 } 1171 }
1169 1172
1170 GLCircleOutside2PtConicalEffect::GLCircleOutside2PtConicalEffect(const GrBackend EffectFactory& factory, 1173 GLCircleOutside2PtConicalEffect::GLCircleOutside2PtConicalEffect(const GrBackend EffectFactory& factory,
1171 const GrDrawEff ect& drawEffect) 1174 const GrEffect& effect)
1172 : INHERITED(factory) 1175 : INHERITED(factory)
1173 , fVSVaryingName(NULL) 1176 , fVSVaryingName(NULL)
1174 , fFSVaryingName(NULL) 1177 , fFSVaryingName(NULL)
1175 , fCachedCenterX(SK_ScalarMax) 1178 , fCachedCenterX(SK_ScalarMax)
1176 , fCachedCenterY(SK_ScalarMax) 1179 , fCachedCenterY(SK_ScalarMax)
1177 , fCachedA(SK_ScalarMax) 1180 , fCachedA(SK_ScalarMax)
1178 , fCachedB(SK_ScalarMax) 1181 , fCachedB(SK_ScalarMax)
1179 , fCachedC(SK_ScalarMax) 1182 , fCachedC(SK_ScalarMax)
1180 , fCachedTLimit(SK_ScalarMax) { 1183 , fCachedTLimit(SK_ScalarMax) {
1181 const CircleOutside2PtConicalEffect& data = drawEffect.castEffect<CircleOuts ide2PtConicalEffect>(); 1184 const CircleOutside2PtConicalEffect& data = effect.cast<CircleOutside2PtConi calEffect>();
1182 fIsFlipped = data.isFlipped(); 1185 fIsFlipped = data.isFlipped();
1183 } 1186 }
1184 1187
1185 void GLCircleOutside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder, 1188 void GLCircleOutside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,
1186 const GrDrawEffect&, 1189 const GrEffect&,
1187 const GrEffectKey& key, 1190 const GrEffectKey& key,
1188 const char* outputColor, 1191 const char* outputColor,
1189 const char* inputColor, 1192 const char* inputColor,
1190 const TransformedCoordsArray& coo rds, 1193 const TransformedCoordsArray& coo rds,
1191 const TextureSamplerArray& sample rs) { 1194 const TextureSamplerArray& sample rs) {
1192 uint32_t baseKey = key.get32(0); 1195 uint32_t baseKey = key.get32(0);
1193 this->emitUniforms(builder, baseKey); 1196 this->emitUniforms(builder, baseKey);
1194 fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 1197 fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
1195 kVec2f_GrSLType, "Conical2FSCenter"); 1198 kVec2f_GrSLType, "Conical2FSCenter");
1196 fParamUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 1199 fParamUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
(...skipping 18 matching lines...) Expand all
1215 // p = coords2D 1218 // p = coords2D
1216 // e = center end 1219 // e = center end
1217 // r = radius end 1220 // r = radius end
1218 // A = dot(e, e) - r^2 + 2 * r - 1 1221 // A = dot(e, e) - r^2 + 2 * r - 1
1219 // B = (r -1) / A 1222 // B = (r -1) / A
1220 // C = 1 / A 1223 // C = 1 / A
1221 // d = dot(e, p) + B 1224 // d = dot(e, p) + B
1222 // t = d +/- sqrt(d^2 - A * dot(p, p) + C) 1225 // t = d +/- sqrt(d^2 - A * dot(p, p) + C)
1223 1226
1224 fsBuilder->codeAppendf("\tfloat pDotp = dot(%s, %s);\n", coords2D, coords2D ); 1227 fsBuilder->codeAppendf("\tfloat pDotp = dot(%s, %s);\n", coords2D, coords2D );
1225 fsBuilder->codeAppendf("\tfloat d = dot(%s, %s) + %s.y;\n", coords2D, cente r.c_str(), params.c_str()); 1228 fsBuilder->codeAppendf("\tfloat d = dot(%s, %s) + %s.y;\n", coords2D, cente r.c_str(),
1226 fsBuilder->codeAppendf("\tfloat deter = d * d - %s.x * pDotp + %s.z;\n", par ams.c_str(), params.c_str()); 1229 params.c_str());
1230 fsBuilder->codeAppendf("\tfloat deter = d * d - %s.x * pDotp + %s.z;\n", par ams.c_str(),
1231 params.c_str());
1227 1232
1228 // Must check to see if we flipped the circle order (to make sure start radi us < end radius) 1233 // Must check to see if we flipped the circle order (to make sure start radi us < end radius)
1229 // If so we must also flip sign on sqrt 1234 // If so we must also flip sign on sqrt
1230 if (!fIsFlipped) { 1235 if (!fIsFlipped) {
1231 fsBuilder->codeAppendf("\tfloat %s = d + sqrt(deter);\n", tName.c_str()) ; 1236 fsBuilder->codeAppendf("\tfloat %s = d + sqrt(deter);\n", tName.c_str()) ;
1232 } else { 1237 } else {
1233 fsBuilder->codeAppendf("\tfloat %s = d - sqrt(deter);\n", tName.c_str()) ; 1238 fsBuilder->codeAppendf("\tfloat %s = d - sqrt(deter);\n", tName.c_str()) ;
1234 } 1239 }
1235 1240
1236 fsBuilder->codeAppendf("\tif (%s >= %s.w && deter >= 0.0) {\n", tName.c_str( ), params.c_str()); 1241 fsBuilder->codeAppendf("\tif (%s >= %s.w && deter >= 0.0) {\n", tName.c_str( ), params.c_str());
1237 fsBuilder->codeAppend("\t\t"); 1242 fsBuilder->codeAppend("\t\t");
1238 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa mplers); 1243 this->emitColor(builder, tName.c_str(), baseKey, outputColor, inputColor, sa mplers);
1239 fsBuilder->codeAppend("\t}\n"); 1244 fsBuilder->codeAppend("\t}\n");
1240 } 1245 }
1241 1246
1242 void GLCircleOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdma n, 1247 void GLCircleOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdma n,
1243 const GrDrawEffect& drawEffect) { 1248 const GrEffect& effect) {
1244 INHERITED::setData(pdman, drawEffect); 1249 INHERITED::setData(pdman, effect);
1245 const CircleOutside2PtConicalEffect& data = drawEffect.castEffect<CircleOuts ide2PtConicalEffect>(); 1250 const CircleOutside2PtConicalEffect& data = effect.cast<CircleOutside2PtConi calEffect>();
1246 SkASSERT(data.isFlipped() == fIsFlipped); 1251 SkASSERT(data.isFlipped() == fIsFlipped);
1247 SkScalar centerX = data.centerX(); 1252 SkScalar centerX = data.centerX();
1248 SkScalar centerY = data.centerY(); 1253 SkScalar centerY = data.centerY();
1249 SkScalar A = data.A(); 1254 SkScalar A = data.A();
1250 SkScalar B = data.B(); 1255 SkScalar B = data.B();
1251 SkScalar C = data.C(); 1256 SkScalar C = data.C();
1252 SkScalar tLimit = data.tLimit(); 1257 SkScalar tLimit = data.tLimit();
1253 1258
1254 if (fCachedCenterX != centerX || fCachedCenterY != centerY || 1259 if (fCachedCenterX != centerX || fCachedCenterY != centerY ||
1255 fCachedA != A || fCachedB != B || fCachedC != C || fCachedTLimit != tLim it) { 1260 fCachedA != A || fCachedB != B || fCachedC != C || fCachedTLimit != tLim it) {
1256 1261
1257 pdman.set2f(fCenterUni, SkScalarToFloat(centerX), SkScalarToFloat(center Y)); 1262 pdman.set2f(fCenterUni, SkScalarToFloat(centerX), SkScalarToFloat(center Y));
1258 pdman.set4f(fParamUni, SkScalarToFloat(A), SkScalarToFloat(B), SkScalarT oFloat(C), 1263 pdman.set4f(fParamUni, SkScalarToFloat(A), SkScalarToFloat(B), SkScalarT oFloat(C),
1259 SkScalarToFloat(tLimit)); 1264 SkScalarToFloat(tLimit));
1260 1265
1261 fCachedCenterX = centerX; 1266 fCachedCenterX = centerX;
1262 fCachedCenterY = centerY; 1267 fCachedCenterY = centerY;
1263 fCachedA = A; 1268 fCachedA = A;
1264 fCachedB = B; 1269 fCachedB = B;
1265 fCachedC = C; 1270 fCachedC = C;
1266 fCachedTLimit = tLimit; 1271 fCachedTLimit = tLimit;
1267 } 1272 }
1268 } 1273 }
1269 1274
1270 void GLCircleOutside2PtConicalEffect::GenKey(const GrDrawEffect& drawEffect, 1275 void GLCircleOutside2PtConicalEffect::GenKey(const GrEffect& effect,
1271 const GrGLCaps&, GrEffectKeyBuilder * b) { 1276 const GrGLCaps&, GrEffectKeyBuilder * b) {
1272 uint32_t* key = b->add32n(2); 1277 uint32_t* key = b->add32n(2);
1273 key[0] = GenBaseGradientKey(drawEffect); 1278 key[0] = GenBaseGradientKey(effect);
1274 key[1] = drawEffect.castEffect<CircleOutside2PtConicalEffect>().isFlipped(); 1279 key[1] = effect.cast<CircleOutside2PtConicalEffect>().isFlipped();
1275 } 1280 }
1276 1281
1277 ////////////////////////////////////////////////////////////////////////////// 1282 //////////////////////////////////////////////////////////////////////////////
1278 1283
1279 GrEffect* Gr2PtConicalGradientEffect::Create(GrContext* ctx, 1284 GrEffect* Gr2PtConicalGradientEffect::Create(GrContext* ctx,
1280 const SkTwoPointConicalGradient& sh ader, 1285 const SkTwoPointConicalGradient& sh ader,
1281 SkShader::TileMode tm, 1286 SkShader::TileMode tm,
1282 const SkMatrix* localMatrix) { 1287 const SkMatrix* localMatrix) {
1283 SkMatrix matrix; 1288 SkMatrix matrix;
1284 if (!shader.getLocalMatrix().invert(&matrix)) { 1289 if (!shader.getLocalMatrix().invert(&matrix)) {
(...skipping 27 matching lines...) Expand all
1312 return CircleInside2PtConicalEffect::Create(ctx, shader, matrix, tm, inf o); 1317 return CircleInside2PtConicalEffect::Create(ctx, shader, matrix, tm, inf o);
1313 } else if (type == kEdge_ConicalType) { 1318 } else if (type == kEdge_ConicalType) {
1314 set_matrix_edge_conical(shader, &matrix); 1319 set_matrix_edge_conical(shader, &matrix);
1315 return Edge2PtConicalEffect::Create(ctx, shader, matrix, tm); 1320 return Edge2PtConicalEffect::Create(ctx, shader, matrix, tm);
1316 } else { 1321 } else {
1317 return CircleOutside2PtConicalEffect::Create(ctx, shader, matrix, tm, in fo); 1322 return CircleOutside2PtConicalEffect::Create(ctx, shader, matrix, tm, in fo);
1318 } 1323 }
1319 } 1324 }
1320 1325
1321 #endif 1326 #endif
OLDNEW
« no previous file with comments | « src/effects/gradients/SkSweepGradient.cpp ('k') | src/effects/gradients/SkTwoPointRadialGradient.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698