OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2013 Google Inc. | 2 * Copyright 2013 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
| 8 #include "gl/builders/GrGLProgramBuilder.h" |
8 #include "GrOvalRenderer.h" | 9 #include "GrOvalRenderer.h" |
9 | 10 |
10 #include "GrEffect.h" | 11 #include "GrEffect.h" |
11 #include "gl/GrGLEffect.h" | 12 #include "gl/GrGLEffect.h" |
12 #include "gl/GrGLSL.h" | 13 #include "gl/GrGLSL.h" |
13 #include "gl/GrGLShaderBuilder.h" | |
14 #include "gl/GrGLVertexEffect.h" | 14 #include "gl/GrGLVertexEffect.h" |
15 #include "GrTBackendEffectFactory.h" | 15 #include "GrTBackendEffectFactory.h" |
16 | 16 |
17 #include "GrDrawState.h" | 17 #include "GrDrawState.h" |
18 #include "GrDrawTarget.h" | 18 #include "GrDrawTarget.h" |
19 #include "GrGpu.h" | 19 #include "GrGpu.h" |
20 | 20 |
21 #include "SkRRect.h" | 21 #include "SkRRect.h" |
22 #include "SkStrokeRec.h" | 22 #include "SkStrokeRec.h" |
23 #include "SkTLazy.h" | 23 #include "SkTLazy.h" |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
88 | 88 |
89 static const char* Name() { return "CircleEdge"; } | 89 static const char* Name() { return "CircleEdge"; } |
90 | 90 |
91 inline bool isStroked() const { return fStroke; } | 91 inline bool isStroked() const { return fStroke; } |
92 | 92 |
93 class GLEffect : public GrGLVertexEffect { | 93 class GLEffect : public GrGLVertexEffect { |
94 public: | 94 public: |
95 GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&) | 95 GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&) |
96 : INHERITED (factory) {} | 96 : INHERITED (factory) {} |
97 | 97 |
98 virtual void emitCode(GrGLFullShaderBuilder* builder, | 98 virtual void emitCode(GrGLFullProgramBuilder* builder, |
99 const GrDrawEffect& drawEffect, | 99 const GrDrawEffect& drawEffect, |
100 const GrEffectKey& key, | 100 const GrEffectKey& key, |
101 const char* outputColor, | 101 const char* outputColor, |
102 const char* inputColor, | 102 const char* inputColor, |
103 const TransformedCoordsArray&, | 103 const TransformedCoordsArray&, |
104 const TextureSamplerArray& samplers) SK_OVERRIDE { | 104 const TextureSamplerArray& samplers) SK_OVERRIDE { |
105 const CircleEdgeEffect& circleEffect = drawEffect.castEffect<CircleE
dgeEffect>(); | 105 const CircleEdgeEffect& circleEffect = drawEffect.castEffect<CircleE
dgeEffect>(); |
106 const char *vsName, *fsName; | 106 const char *vsName, *fsName; |
107 builder->addVarying(kVec4f_GrSLType, "CircleEdge", &vsName, &fsName)
; | 107 builder->addVarying(kVec4f_GrSLType, "CircleEdge", &vsName, &fsName)
; |
108 | 108 |
109 const SkString* attrName = | 109 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder
(); |
110 builder->getEffectAttributeName(drawEffect.getVertexAttribIndice
s()[0]); | 110 const SkString* attr0Name = |
111 builder->vsCodeAppendf("\t%s = %s;\n", vsName, attrName->c_str()); | 111 vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndi
ces()[0]); |
| 112 vsBuilder->codeAppendf("\t%s = %s;\n", vsName, attr0Name->c_str()); |
112 | 113 |
113 builder->fsCodeAppendf("\tfloat d = length(%s.xy);\n", fsName); | 114 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBui
lder(); |
114 builder->fsCodeAppendf("\tfloat edgeAlpha = clamp(%s.z - d, 0.0, 1.0
);\n", fsName); | 115 fsBuilder->codeAppendf("\tfloat d = length(%s.xy);\n", fsName); |
| 116 fsBuilder->codeAppendf("\tfloat edgeAlpha = clamp(%s.z - d, 0.0, 1.0
);\n", fsName); |
115 if (circleEffect.isStroked()) { | 117 if (circleEffect.isStroked()) { |
116 builder->fsCodeAppendf("\tfloat innerAlpha = clamp(d - %s.w, 0.0
, 1.0);\n", fsName); | 118 fsBuilder->codeAppendf("\tfloat innerAlpha = clamp(d - %s.w, 0.0
, 1.0);\n", fsName); |
117 builder->fsCodeAppend("\tedgeAlpha *= innerAlpha;\n"); | 119 fsBuilder->codeAppend("\tedgeAlpha *= innerAlpha;\n"); |
118 } | 120 } |
119 | 121 |
120 builder->fsCodeAppendf("\t%s = %s;\n", outputColor, | 122 fsBuilder->codeAppendf("\t%s = %s;\n", outputColor, |
121 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeA
lpha")).c_str()); | 123 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeA
lpha")).c_str()); |
122 } | 124 } |
123 | 125 |
124 static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, | 126 static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, |
125 GrEffectKeyBuilder* b) { | 127 GrEffectKeyBuilder* b) { |
126 const CircleEdgeEffect& circleEffect = drawEffect.castEffect<CircleE
dgeEffect>(); | 128 const CircleEdgeEffect& circleEffect = drawEffect.castEffect<CircleE
dgeEffect>(); |
127 b->add32(circleEffect.isStroked()); | 129 b->add32(circleEffect.isStroked()); |
128 } | 130 } |
129 | 131 |
130 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&)
SK_OVERRIDE {} | 132 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&)
SK_OVERRIDE {} |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
199 | 201 |
200 static const char* Name() { return "EllipseEdge"; } | 202 static const char* Name() { return "EllipseEdge"; } |
201 | 203 |
202 inline bool isStroked() const { return fStroke; } | 204 inline bool isStroked() const { return fStroke; } |
203 | 205 |
204 class GLEffect : public GrGLVertexEffect { | 206 class GLEffect : public GrGLVertexEffect { |
205 public: | 207 public: |
206 GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&) | 208 GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&) |
207 : INHERITED (factory) {} | 209 : INHERITED (factory) {} |
208 | 210 |
209 virtual void emitCode(GrGLFullShaderBuilder* builder, | 211 virtual void emitCode(GrGLFullProgramBuilder* builder, |
210 const GrDrawEffect& drawEffect, | 212 const GrDrawEffect& drawEffect, |
211 const GrEffectKey& key, | 213 const GrEffectKey& key, |
212 const char* outputColor, | 214 const char* outputColor, |
213 const char* inputColor, | 215 const char* inputColor, |
214 const TransformedCoordsArray&, | 216 const TransformedCoordsArray&, |
215 const TextureSamplerArray& samplers) SK_OVERRIDE { | 217 const TextureSamplerArray& samplers) SK_OVERRIDE { |
216 const EllipseEdgeEffect& ellipseEffect = drawEffect.castEffect<Ellip
seEdgeEffect>(); | 218 const EllipseEdgeEffect& ellipseEffect = drawEffect.castEffect<Ellip
seEdgeEffect>(); |
217 | 219 |
218 const char *vsOffsetName, *fsOffsetName; | 220 const char *vsOffsetName, *fsOffsetName; |
219 const char *vsRadiiName, *fsRadiiName; | 221 const char *vsRadiiName, *fsRadiiName; |
220 | 222 |
221 builder->addVarying(kVec2f_GrSLType, "EllipseOffsets", &vsOffsetName
, &fsOffsetName); | 223 builder->addVarying(kVec2f_GrSLType, "EllipseOffsets", &vsOffsetName
, &fsOffsetName); |
| 224 |
| 225 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder
(); |
222 const SkString* attr0Name = | 226 const SkString* attr0Name = |
223 builder->getEffectAttributeName(drawEffect.getVertexAttribIndice
s()[0]); | 227 vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndi
ces()[0]); |
224 builder->vsCodeAppendf("\t%s = %s;\n", vsOffsetName, attr0Name->c_st
r()); | 228 vsBuilder->codeAppendf("\t%s = %s;\n", vsOffsetName, attr0Name->c_st
r()); |
225 | 229 |
226 builder->addVarying(kVec4f_GrSLType, "EllipseRadii", &vsRadiiName, &
fsRadiiName); | 230 builder->addVarying(kVec4f_GrSLType, "EllipseRadii", &vsRadiiName, &
fsRadiiName); |
227 const SkString* attr1Name = | 231 const SkString* attr1Name = |
228 builder->getEffectAttributeName(drawEffect.getVertexAttribIndice
s()[1]); | 232 vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndi
ces()[1]); |
229 builder->vsCodeAppendf("\t%s = %s;\n", vsRadiiName, attr1Name->c_str
()); | 233 vsBuilder->codeAppendf("\t%s = %s;\n", vsRadiiName, attr1Name->c_str
()); |
230 | 234 |
231 // for outer curve | 235 // for outer curve |
232 builder->fsCodeAppendf("\tvec2 scaledOffset = %s*%s.xy;\n", fsOffset
Name, fsRadiiName); | 236 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBui
lder(); |
233 builder->fsCodeAppend("\tfloat test = dot(scaledOffset, scaledOffset
) - 1.0;\n"); | 237 fsBuilder->codeAppendf("\tvec2 scaledOffset = %s*%s.xy;\n", fsOffset
Name, fsRadiiName); |
234 builder->fsCodeAppendf("\tvec2 grad = 2.0*scaledOffset*%s.xy;\n", fs
RadiiName); | 238 fsBuilder->codeAppend("\tfloat test = dot(scaledOffset, scaledOffset
) - 1.0;\n"); |
235 builder->fsCodeAppend("\tfloat grad_dot = dot(grad, grad);\n"); | 239 fsBuilder->codeAppendf("\tvec2 grad = 2.0*scaledOffset*%s.xy;\n", fs
RadiiName); |
| 240 fsBuilder->codeAppend("\tfloat grad_dot = dot(grad, grad);\n"); |
236 // avoid calling inversesqrt on zero. | 241 // avoid calling inversesqrt on zero. |
237 builder->fsCodeAppend("\tgrad_dot = max(grad_dot, 1.0e-4);\n"); | 242 fsBuilder->codeAppend("\tgrad_dot = max(grad_dot, 1.0e-4);\n"); |
238 builder->fsCodeAppend("\tfloat invlen = inversesqrt(grad_dot);\n"); | 243 fsBuilder->codeAppend("\tfloat invlen = inversesqrt(grad_dot);\n"); |
239 builder->fsCodeAppend("\tfloat edgeAlpha = clamp(0.5-test*invlen, 0.
0, 1.0);\n"); | 244 fsBuilder->codeAppend("\tfloat edgeAlpha = clamp(0.5-test*invlen, 0.
0, 1.0);\n"); |
240 | 245 |
241 // for inner curve | 246 // for inner curve |
242 if (ellipseEffect.isStroked()) { | 247 if (ellipseEffect.isStroked()) { |
243 builder->fsCodeAppendf("\tscaledOffset = %s*%s.zw;\n", fsOffsetN
ame, fsRadiiName); | 248 fsBuilder->codeAppendf("\tscaledOffset = %s*%s.zw;\n", fsOffsetN
ame, fsRadiiName); |
244 builder->fsCodeAppend("\ttest = dot(scaledOffset, scaledOffset)
- 1.0;\n"); | 249 fsBuilder->codeAppend("\ttest = dot(scaledOffset, scaledOffset)
- 1.0;\n"); |
245 builder->fsCodeAppendf("\tgrad = 2.0*scaledOffset*%s.zw;\n", fsR
adiiName); | 250 fsBuilder->codeAppendf("\tgrad = 2.0*scaledOffset*%s.zw;\n", fsR
adiiName); |
246 builder->fsCodeAppend("\tinvlen = inversesqrt(dot(grad, grad));\
n"); | 251 fsBuilder->codeAppend("\tinvlen = inversesqrt(dot(grad, grad));\
n"); |
247 builder->fsCodeAppend("\tedgeAlpha *= clamp(0.5+test*invlen, 0.0
, 1.0);\n"); | 252 fsBuilder->codeAppend("\tedgeAlpha *= clamp(0.5+test*invlen, 0.0
, 1.0);\n"); |
248 } | 253 } |
249 | 254 |
250 builder->fsCodeAppendf("\t%s = %s;\n", outputColor, | 255 fsBuilder->codeAppendf("\t%s = %s;\n", outputColor, |
251 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeA
lpha")).c_str()); | 256 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeA
lpha")).c_str()); |
252 } | 257 } |
253 | 258 |
254 static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, | 259 static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, |
255 GrEffectKeyBuilder* b) { | 260 GrEffectKeyBuilder* b) { |
256 const EllipseEdgeEffect& ellipseEffect = drawEffect.castEffect<Ellip
seEdgeEffect>(); | 261 const EllipseEdgeEffect& ellipseEffect = drawEffect.castEffect<Ellip
seEdgeEffect>(); |
257 b->add32(ellipseEffect.isStroked()); | 262 b->add32(ellipseEffect.isStroked()); |
258 } | 263 } |
259 | 264 |
260 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&)
SK_OVERRIDE { | 265 virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&)
SK_OVERRIDE { |
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
337 | 342 |
338 static const char* Name() { return "DIEllipseEdge"; } | 343 static const char* Name() { return "DIEllipseEdge"; } |
339 | 344 |
340 inline Mode getMode() const { return fMode; } | 345 inline Mode getMode() const { return fMode; } |
341 | 346 |
342 class GLEffect : public GrGLVertexEffect { | 347 class GLEffect : public GrGLVertexEffect { |
343 public: | 348 public: |
344 GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&) | 349 GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&) |
345 : INHERITED (factory) {} | 350 : INHERITED (factory) {} |
346 | 351 |
347 virtual void emitCode(GrGLFullShaderBuilder* builder, | 352 virtual void emitCode(GrGLFullProgramBuilder* builder, |
348 const GrDrawEffect& drawEffect, | 353 const GrDrawEffect& drawEffect, |
349 const GrEffectKey& key, | 354 const GrEffectKey& key, |
350 const char* outputColor, | 355 const char* outputColor, |
351 const char* inputColor, | 356 const char* inputColor, |
352 const TransformedCoordsArray&, | 357 const TransformedCoordsArray&, |
353 const TextureSamplerArray& samplers) SK_OVERRIDE { | 358 const TextureSamplerArray& samplers) SK_OVERRIDE { |
354 const DIEllipseEdgeEffect& ellipseEffect = drawEffect.castEffect<DIE
llipseEdgeEffect>(); | 359 const DIEllipseEdgeEffect& ellipseEffect = drawEffect.castEffect<DIE
llipseEdgeEffect>(); |
355 | 360 |
356 SkAssertResult(builder->enableFeature( | |
357 GrGLShaderBuilder::kStandardDeriva
tives_GLSLFeature)); | |
358 | |
359 const char *vsOffsetName0, *fsOffsetName0; | 361 const char *vsOffsetName0, *fsOffsetName0; |
360 builder->addVarying(kVec2f_GrSLType, "EllipseOffsets0", | 362 builder->addVarying(kVec2f_GrSLType, "EllipseOffsets0", |
361 &vsOffsetName0, &fsOffsetName0); | 363 &vsOffsetName0, &fsOffsetName0); |
| 364 |
| 365 GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder
(); |
362 const SkString* attr0Name = | 366 const SkString* attr0Name = |
363 builder->getEffectAttributeName(drawEffect.getVertexAttribIndice
s()[0]); | 367 vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndi
ces()[0]); |
364 builder->vsCodeAppendf("\t%s = %s;\n", vsOffsetName0, attr0Name->c_s
tr()); | 368 vsBuilder->codeAppendf("\t%s = %s;\n", vsOffsetName0, attr0Name->c_s
tr()); |
365 const char *vsOffsetName1, *fsOffsetName1; | 369 const char *vsOffsetName1, *fsOffsetName1; |
366 builder->addVarying(kVec2f_GrSLType, "EllipseOffsets1", | 370 builder->addVarying(kVec2f_GrSLType, "EllipseOffsets1", |
367 &vsOffsetName1, &fsOffsetName1); | 371 &vsOffsetName1, &fsOffsetName1); |
368 const SkString* attr1Name = | 372 const SkString* attr1Name = |
369 builder->getEffectAttributeName(drawEffect.getVertexAttribIndice
s()[1]); | 373 vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndi
ces()[1]); |
370 builder->vsCodeAppendf("\t%s = %s;\n", vsOffsetName1, attr1Name->c_s
tr()); | 374 vsBuilder->codeAppendf("\t%s = %s;\n", vsOffsetName1, attr1Name->c_s
tr()); |
371 | 375 |
| 376 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBui
lder(); |
| 377 SkAssertResult(fsBuilder->enableFeature( |
| 378 GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature)
); |
372 // for outer curve | 379 // for outer curve |
373 builder->fsCodeAppendf("\tvec2 scaledOffset = %s.xy;\n", fsOffsetNam
e0); | 380 fsBuilder->codeAppendf("\tvec2 scaledOffset = %s.xy;\n", fsOffsetNam
e0); |
374 builder->fsCodeAppend("\tfloat test = dot(scaledOffset, scaledOffset
) - 1.0;\n"); | 381 fsBuilder->codeAppend("\tfloat test = dot(scaledOffset, scaledOffset
) - 1.0;\n"); |
375 builder->fsCodeAppendf("\tvec2 duvdx = dFdx(%s);\n", fsOffsetName0); | 382 fsBuilder->codeAppendf("\tvec2 duvdx = dFdx(%s);\n", fsOffsetName0); |
376 builder->fsCodeAppendf("\tvec2 duvdy = dFdy(%s);\n", fsOffsetName0); | 383 fsBuilder->codeAppendf("\tvec2 duvdy = dFdy(%s);\n", fsOffsetName0); |
377 builder->fsCodeAppendf("\tvec2 grad = vec2(2.0*%s.x*duvdx.x + 2.0*%s
.y*duvdx.y,\n" | 384 fsBuilder->codeAppendf("\tvec2 grad = vec2(2.0*%s.x*duvdx.x + 2.0*%s
.y*duvdx.y,\n" |
378 "\t 2.0*%s.x*duvdy.x + 2.0*%s
.y*duvdy.y);\n", | 385 "\t 2.0*%s.x*duvdy.x + 2.0*%s
.y*duvdy.y);\n", |
379 fsOffsetName0, fsOffsetName0, fsOffsetName0,
fsOffsetName0); | 386 fsOffsetName0, fsOffsetName0, fsOffsetName0,
fsOffsetName0); |
380 | 387 |
381 builder->fsCodeAppend("\tfloat grad_dot = dot(grad, grad);\n"); | 388 fsBuilder->codeAppend("\tfloat grad_dot = dot(grad, grad);\n"); |
382 // avoid calling inversesqrt on zero. | 389 // avoid calling inversesqrt on zero. |
383 builder->fsCodeAppend("\tgrad_dot = max(grad_dot, 1.0e-4);\n"); | 390 fsBuilder->codeAppend("\tgrad_dot = max(grad_dot, 1.0e-4);\n"); |
384 builder->fsCodeAppend("\tfloat invlen = inversesqrt(grad_dot);\n"); | 391 fsBuilder->codeAppend("\tfloat invlen = inversesqrt(grad_dot);\n"); |
385 if (kHairline == ellipseEffect.getMode()) { | 392 if (kHairline == ellipseEffect.getMode()) { |
386 // can probably do this with one step | 393 // can probably do this with one step |
387 builder->fsCodeAppend("\tfloat edgeAlpha = clamp(1.0-test*invlen
, 0.0, 1.0);\n"); | 394 fsBuilder->codeAppend("\tfloat edgeAlpha = clamp(1.0-test*invlen
, 0.0, 1.0);\n"); |
388 builder->fsCodeAppend("\tedgeAlpha *= clamp(1.0+test*invlen, 0.0
, 1.0);\n"); | 395 fsBuilder->codeAppend("\tedgeAlpha *= clamp(1.0+test*invlen, 0.0
, 1.0);\n"); |
389 } else { | 396 } else { |
390 builder->fsCodeAppend("\tfloat edgeAlpha = clamp(0.5-test*invlen
, 0.0, 1.0);\n"); | 397 fsBuilder->codeAppend("\tfloat edgeAlpha = clamp(0.5-test*invlen
, 0.0, 1.0);\n"); |
391 } | 398 } |
392 | 399 |
393 // for inner curve | 400 // for inner curve |
394 if (kStroke == ellipseEffect.getMode()) { | 401 if (kStroke == ellipseEffect.getMode()) { |
395 builder->fsCodeAppendf("\tscaledOffset = %s.xy;\n", fsOffsetName
1); | 402 fsBuilder->codeAppendf("\tscaledOffset = %s.xy;\n", fsOffsetName
1); |
396 builder->fsCodeAppend("\ttest = dot(scaledOffset, scaledOffset)
- 1.0;\n"); | 403 fsBuilder->codeAppend("\ttest = dot(scaledOffset, scaledOffset)
- 1.0;\n"); |
397 builder->fsCodeAppendf("\tduvdx = dFdx(%s);\n", fsOffsetName1); | 404 fsBuilder->codeAppendf("\tduvdx = dFdx(%s);\n", fsOffsetName1); |
398 builder->fsCodeAppendf("\tduvdy = dFdy(%s);\n", fsOffsetName1); | 405 fsBuilder->codeAppendf("\tduvdy = dFdy(%s);\n", fsOffsetName1); |
399 builder->fsCodeAppendf("\tgrad = vec2(2.0*%s.x*duvdx.x + 2.0*%s.
y*duvdx.y,\n" | 406 fsBuilder->codeAppendf("\tgrad = vec2(2.0*%s.x*duvdx.x + 2.0*%s.
y*duvdx.y,\n" |
400 "\t 2.0*%s.x*duvdy.x + 2.0*%s.
y*duvdy.y);\n", | 407 "\t 2.0*%s.x*duvdy.x + 2.0*%s.
y*duvdy.y);\n", |
401 fsOffsetName1, fsOffsetName1, fsOffsetNam
e1, fsOffsetName1); | 408 fsOffsetName1, fsOffsetName1, fsOffsetNam
e1, fsOffsetName1); |
402 builder->fsCodeAppend("\tinvlen = inversesqrt(dot(grad, grad));\
n"); | 409 fsBuilder->codeAppend("\tinvlen = inversesqrt(dot(grad, grad));\
n"); |
403 builder->fsCodeAppend("\tedgeAlpha *= clamp(0.5+test*invlen, 0.0
, 1.0);\n"); | 410 fsBuilder->codeAppend("\tedgeAlpha *= clamp(0.5+test*invlen, 0.0
, 1.0);\n"); |
404 } | 411 } |
405 | 412 |
406 builder->fsCodeAppendf("\t%s = %s;\n", outputColor, | 413 fsBuilder->codeAppendf("\t%s = %s;\n", outputColor, |
407 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeA
lpha")).c_str()); | 414 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeA
lpha")).c_str()); |
408 } | 415 } |
409 | 416 |
410 static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, | 417 static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, |
411 GrEffectKeyBuilder* b) { | 418 GrEffectKeyBuilder* b) { |
412 const DIEllipseEdgeEffect& ellipseEffect = | 419 const DIEllipseEdgeEffect& ellipseEffect = |
413 drawEffect.castEffect<DIEllipseEdgeEffect>(); | 420 drawEffect.castEffect<DIEllipseEdgeEffect>(); |
414 | 421 |
415 b->add32(ellipseEffect.getMode()); | 422 b->add32(ellipseEffect.getMode()); |
416 } | 423 } |
(...skipping 801 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1218 | 1225 |
1219 // drop out the middle quad if we're stroked | 1226 // drop out the middle quad if we're stroked |
1220 int indexCnt = isStrokeOnly ? SK_ARRAY_COUNT(gRRectIndices) - 6 : | 1227 int indexCnt = isStrokeOnly ? SK_ARRAY_COUNT(gRRectIndices) - 6 : |
1221 SK_ARRAY_COUNT(gRRectIndices); | 1228 SK_ARRAY_COUNT(gRRectIndices); |
1222 target->setIndexSourceToBuffer(indexBuffer); | 1229 target->setIndexSourceToBuffer(indexBuffer); |
1223 target->drawIndexed(kTriangles_GrPrimitiveType, 0, 0, 16, indexCnt, &bou
nds); | 1230 target->drawIndexed(kTriangles_GrPrimitiveType, 0, 0, 16, indexCnt, &bou
nds); |
1224 } | 1231 } |
1225 | 1232 |
1226 return true; | 1233 return true; |
1227 } | 1234 } |
OLD | NEW |