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