OLD | NEW |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 Loading... |
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 |
OLD | NEW |