1 /* 2 * Copyright 2013 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #include "GrOvalRenderer.h" 9 10 #include "GrEffect.h" 11 #include "gl/GrGLEffect.h" 12 #include "gl/GrGLSL.h" 13 #include "gl/GrGLVertexEffect.h" 14 #include "GrTBackendEffectFactory.h" 15 16 #include "GrDrawState.h" 17 #include "GrDrawTarget.h" 18 #include "GrGpu.h" 19 20 #include "SkRRect.h" 21 #include "SkStrokeRec.h" 22 23 #include "effects/GrVertexEffect.h" 24 25 namespace { 26 27 struct CircleVertex { 28 GrPoint fPos; 29 GrPoint fOffset; 30 SkScalar fOuterRadius; 31 SkScalar fInnerRadius; 32 }; 33 34 struct EllipseVertex { 35 GrPoint fPos; 36 GrPoint fOffset; 37 GrPoint fOuterRadii; 38 GrPoint fInnerRadii; 39 }; 40 41 struct DIEllipseVertex { 42 GrPoint fPos; 43 GrPoint fOuterOffset; 44 GrPoint fInnerOffset; 45 }; 46 47 inline bool circle_stays_circle(const SkMatrix& m) { 48 return m.isSimilarity(); 49 } 50 51 } 52 53 /////////////////////////////////////////////////////////////////////////////// 54 55 /** 56 * The output of this effect is a modulation of the input color and coverage for a circle, 57 * specified as offset_x, offset_y (both from center point), outer radius and inner radius. 58 */ 59 60 class CircleEdgeEffect : public GrVertexEffect { 61 public: 62 static GrEffectRef* Create(bool stroke) { 63 GR_CREATE_STATIC_EFFECT(gCircleStrokeEdge, CircleEdgeEffect, (true)); 64 GR_CREATE_STATIC_EFFECT(gCircleFillEdge, CircleEdgeEffect, (false)); 65 66 if (stroke) { 67 gCircleStrokeEdge->ref(); 68 return gCircleStrokeEdge; 69 } else { 70 gCircleFillEdge->ref(); 71 return gCircleFillEdge; 72 } 73 } 74 75 virtual void getConstantColorComponents(GrColor* color, 76 uint32_t* validFlags) const SK_OVERRIDE { 77 *validFlags = 0; 78 } 79 80 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE { 81 return GrTBackendEffectFactory<CircleEdgeEffect>::getInstance(); 82 } 83 84 virtual ~CircleEdgeEffect() {} 85 86 static const char* Name() { return "CircleEdge"; } 87 88 inline bool isStroked() const { return fStroke; } 89 90 class GLEffect : public GrGLVertexEffect { 91 public: 92 GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&) 93 : INHERITED (factory) {} 94 95 virtual void emitCode(GrGLFullShaderBuilder* builder, 96 const GrDrawEffect& drawEffect, 97 EffectKey key, 98 const char* outputColor, 99 const char* inputColor, 100 const TransformedCoordsArray&, 101 const TextureSamplerArray& samplers) SK_OVERRIDE { 102 const CircleEdgeEffect& circleEffect = drawEffect.castEffect<CircleEdgeEffect>(); 103 const char *vsName, *fsName; 104 builder->addVarying(kVec4f_GrSLType, "CircleEdge", &vsName, &fsName); 105 106 const SkString* attrName = 107 builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]); 108 builder->vsCodeAppendf("\t%s = %s;\n", vsName, attrName->c_str()); 109 110 builder->fsCodeAppendf("\tfloat d = length(%s.xy);\n", fsName); 111 builder->fsCodeAppendf("\tfloat edgeAlpha = clamp(%s.z - d, 0.0, 1.0);\n", fsName); 112 if (circleEffect.isStroked()) { 113 builder->fsCodeAppendf("\tfloat innerAlpha = clamp(d - %s.w, 0.0, 1.0);\n", fsName); 114 builder->fsCodeAppend("\tedgeAlpha *= innerAlpha;\n"); 115 } 116 117 builder->fsCodeAppendf("\t%s = %s;\n", outputColor, 118 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).c_str()); 119 } 120 121 static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) { 122 const CircleEdgeEffect& circleEffect = drawEffect.castEffect<CircleEdgeEffect>(); 123 124 return circleEffect.isStroked() ? 0x1 : 0x0; 125 } 126 127 virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE {} 128 129 private: 130 typedef GrGLVertexEffect INHERITED; 131 }; 132 133 134 private: 135 CircleEdgeEffect(bool stroke) : GrVertexEffect() { 136 this->addVertexAttrib(kVec4f_GrSLType); 137 fStroke = stroke; 138 } 139 140 virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE { 141 const CircleEdgeEffect& cee = CastEffect<CircleEdgeEffect>(other); 142 return cee.fStroke == fStroke; 143 } 144 145 bool fStroke; 146 147 GR_DECLARE_EFFECT_TEST; 148 149 typedef GrVertexEffect INHERITED; 150 }; 151 152 GR_DEFINE_EFFECT_TEST(CircleEdgeEffect); 153 154 GrEffectRef* CircleEdgeEffect::TestCreate(SkRandom* random, 155 GrContext* context, 156 const GrDrawTargetCaps&, 157 GrTexture* textures[]) { 158 return CircleEdgeEffect::Create(random->nextBool()); 159 } 160 161 /////////////////////////////////////////////////////////////////////////////// 162 163 /** 164 * The output of this effect is a modulation of the input color and coverage for an axis-aligned 165 * ellipse, specified as a 2D offset from center, and the reciprocals of the outer and inner radii, 166 * in both x and y directions. 167 * 168 * We are using an implicit function of x^2/a^2 + y^2/b^2 - 1 = 0. 169 */ 170 171 class EllipseEdgeEffect : public GrVertexEffect { 172 public: 173 static GrEffectRef* Create(bool stroke) { 174 GR_CREATE_STATIC_EFFECT(gEllipseStrokeEdge, EllipseEdgeEffect, (true)); 175 GR_CREATE_STATIC_EFFECT(gEllipseFillEdge, EllipseEdgeEffect, (false)); 176 177 if (stroke) { 178 gEllipseStrokeEdge->ref(); 179 return gEllipseStrokeEdge; 180 } else { 181 gEllipseFillEdge->ref(); 182 return gEllipseFillEdge; 183 } 184 } 185 186 virtual void getConstantColorComponents(GrColor* color, 187 uint32_t* validFlags) const SK_OVERRIDE { 188 *validFlags = 0; 189 } 190 191 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE { 192 return GrTBackendEffectFactory<EllipseEdgeEffect>::getInstance(); 193 } 194 195 virtual ~EllipseEdgeEffect() {} 196 197 static const char* Name() { return "EllipseEdge"; } 198 199 inline bool isStroked() const { return fStroke; } 200 201 class GLEffect : public GrGLVertexEffect { 202 public: 203 GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&) 204 : INHERITED (factory) {} 205 206 virtual void emitCode(GrGLFullShaderBuilder* builder, 207 const GrDrawEffect& drawEffect, 208 EffectKey key, 209 const char* outputColor, 210 const char* inputColor, 211 const TransformedCoordsArray&, 212 const TextureSamplerArray& samplers) SK_OVERRIDE { 213 const EllipseEdgeEffect& ellipseEffect = drawEffect.castEffect<EllipseEdgeEffect>(); 214 215 const char *vsOffsetName, *fsOffsetName; 216 const char *vsRadiiName, *fsRadiiName; 217 218 builder->addVarying(kVec2f_GrSLType, "EllipseOffsets", &vsOffsetName, &fsOffsetName); 219 const SkString* attr0Name = 220 builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]); 221 builder->vsCodeAppendf("\t%s = %s;\n", vsOffsetName, attr0Name->c_str()); 222 223 builder->addVarying(kVec4f_GrSLType, "EllipseRadii", &vsRadiiName, &fsRadiiName); 224 const SkString* attr1Name = 225 builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[1]); 226 builder->vsCodeAppendf("\t%s = %s;\n", vsRadiiName, attr1Name->c_str()); 227 228 // for outer curve 229 builder->fsCodeAppendf("\tvec2 scaledOffset = %s*%s.xy;\n", fsOffsetName, fsRadiiName); 230 builder->fsCodeAppend("\tfloat test = dot(scaledOffset, scaledOffset) - 1.0;\n"); 231 builder->fsCodeAppendf("\tvec2 grad = 2.0*scaledOffset*%s.xy;\n", fsRadiiName); 232 builder->fsCodeAppend("\tfloat grad_dot = dot(grad, grad);\n"); 233 // we need to clamp the length^2 of the gradiant vector to a non-zero value, because 234 // on the Nexus 4 the undefined result of inversesqrt(0) drops out an entire tile 235 // TODO: restrict this to Adreno-only 236 builder->fsCodeAppend("\tgrad_dot = max(grad_dot, 1.0e-4);\n"); 237 builder->fsCodeAppend("\tfloat invlen = inversesqrt(grad_dot);\n"); 238 builder->fsCodeAppend("\tfloat edgeAlpha = clamp(0.5-test*invlen, 0.0, 1.0);\n"); 239 240 // for inner curve 241 if (ellipseEffect.isStroked()) { 242 builder->fsCodeAppendf("\tscaledOffset = %s*%s.zw;\n", fsOffsetName, fsRadiiName); 243 builder->fsCodeAppend("\ttest = dot(scaledOffset, scaledOffset) - 1.0;\n"); 244 builder->fsCodeAppendf("\tgrad = 2.0*scaledOffset*%s.zw;\n", fsRadiiName); 245 builder->fsCodeAppend("\tinvlen = inversesqrt(dot(grad, grad));\n"); 246 builder->fsCodeAppend("\tedgeAlpha *= clamp(0.5+test*invlen, 0.0, 1.0);\n"); 247 } 248 249 builder->fsCodeAppendf("\t%s = %s;\n", outputColor, 250 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).c_str()); 251 } 252 253 static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) { 254 const EllipseEdgeEffect& ellipseEffect = drawEffect.castEffect<EllipseEdgeEffect>(); 255 256 return ellipseEffect.isStroked() ? 0x1 : 0x0; 257 } 258 259 virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE { 260 } 261 262 private: 263 typedef GrGLVertexEffect INHERITED; 264 }; 265 266 private: 267 EllipseEdgeEffect(bool stroke) : GrVertexEffect() { 268 this->addVertexAttrib(kVec2f_GrSLType); 269 this->addVertexAttrib(kVec4f_GrSLType); 270 fStroke = stroke; 271 } 272 273 virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE { 274 const EllipseEdgeEffect& eee = CastEffect<EllipseEdgeEffect>(other); 275 return eee.fStroke == fStroke; 276 } 277 278 bool fStroke; 279 280 GR_DECLARE_EFFECT_TEST; 281 282 typedef GrVertexEffect INHERITED; 283 }; 284 285 GR_DEFINE_EFFECT_TEST(EllipseEdgeEffect); 286 287 GrEffectRef* EllipseEdgeEffect::TestCreate(SkRandom* random, 288 GrContext* context, 289 const GrDrawTargetCaps&, 290 GrTexture* textures[]) { 291 return EllipseEdgeEffect::Create(random->nextBool()); 292 } 293 294 /////////////////////////////////////////////////////////////////////////////// 295 296 /** 297 * The output of this effect is a modulation of the input color and coverage for an ellipse, 298 * specified as a 2D offset from center for both the outer and inner paths (if stroked). The 299 * implict equation used is for a unit circle (x^2 + y^2 - 1 = 0) and the edge corrected by 300 * using differentials. 301 * 302 * The result is device-independent and can be used with any affine matrix. 303 */ 304 305 class DIEllipseEdgeEffect : public GrVertexEffect { 306 public: 307 enum Mode { kStroke = 0, kHairline, kFill }; 308 309 static GrEffectRef* Create(Mode mode) { 310 GR_CREATE_STATIC_EFFECT(gEllipseStrokeEdge, DIEllipseEdgeEffect, (kStroke)); 311 GR_CREATE_STATIC_EFFECT(gEllipseHairlineEdge, DIEllipseEdgeEffect, (kHairline)); 312 GR_CREATE_STATIC_EFFECT(gEllipseFillEdge, DIEllipseEdgeEffect, (kFill)); 313 314 if (kStroke == mode) { 315 gEllipseStrokeEdge->ref(); 316 return gEllipseStrokeEdge; 317 } else if (kHairline == mode) { 318 gEllipseHairlineEdge->ref(); 319 return gEllipseHairlineEdge; 320 } else { 321 gEllipseFillEdge->ref(); 322 return gEllipseFillEdge; 323 } 324 } 325 326 virtual void getConstantColorComponents(GrColor* color, 327 uint32_t* validFlags) const SK_OVERRIDE { 328 *validFlags = 0; 329 } 330 331 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE { 332 return GrTBackendEffectFactory<DIEllipseEdgeEffect>::getInstance(); 333 } 334 335 virtual ~DIEllipseEdgeEffect() {} 336 337 static const char* Name() { return "DIEllipseEdge"; } 338 339 inline Mode getMode() const { return fMode; } 340 341 class GLEffect : public GrGLVertexEffect { 342 public: 343 GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&) 344 : INHERITED (factory) {} 345 346 virtual void emitCode(GrGLFullShaderBuilder* builder, 347 const GrDrawEffect& drawEffect, 348 EffectKey key, 349 const char* outputColor, 350 const char* inputColor, 351 const TransformedCoordsArray&, 352 const TextureSamplerArray& samplers) SK_OVERRIDE { 353 const DIEllipseEdgeEffect& ellipseEffect = drawEffect.castEffect<DIEllipseEdgeEffect>(); 354 355 SkAssertResult(builder->enableFeature( 356 GrGLShaderBuilder::kStandardDerivatives_GLSLFeature)); 357 358 const char *vsOffsetName0, *fsOffsetName0; 359 builder->addVarying(kVec2f_GrSLType, "EllipseOffsets0", 360 &vsOffsetName0, &fsOffsetName0); 361 const SkString* attr0Name = 362 builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]); 363 builder->vsCodeAppendf("\t%s = %s;\n", vsOffsetName0, attr0Name->c_str()); 364 const char *vsOffsetName1, *fsOffsetName1; 365 builder->addVarying(kVec2f_GrSLType, "EllipseOffsets1", 366 &vsOffsetName1, &fsOffsetName1); 367 const SkString* attr1Name = 368 builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[1]); 369 builder->vsCodeAppendf("\t%s = %s;\n", vsOffsetName1, attr1Name->c_str()); 370 371 // for outer curve 372 builder->fsCodeAppendf("\tvec2 scaledOffset = %s.xy;\n", fsOffsetName0); 373 builder->fsCodeAppend("\tfloat test = dot(scaledOffset, scaledOffset) - 1.0;\n"); 374 builder->fsCodeAppendf("\tvec2 duvdx = dFdx(%s);\n", fsOffsetName0); 375 builder->fsCodeAppendf("\tvec2 duvdy = dFdy(%s);\n", fsOffsetName0); 376 builder->fsCodeAppendf("\tvec2 grad = vec2(2.0*%s.x*duvdx.x + 2.0*%s.y*duvdx.y,\n" 377 "\t 2.0*%s.x*duvdy.x + 2.0*%s.y*duvdy.y);\n", 378 fsOffsetName0, fsOffsetName0, fsOffsetName0, fsOffsetName0); 379 380 builder->fsCodeAppend("\tfloat grad_dot = dot(grad, grad);\n"); 381 // we need to clamp the length^2 of the gradiant vector to a non-zero value, because 382 // on the Nexus 4 the undefined result of inversesqrt(0) drops out an entire tile 383 // TODO: restrict this to Adreno-only 384 builder->fsCodeAppend("\tgrad_dot = max(grad_dot, 1.0e-4);\n"); 385 builder->fsCodeAppend("\tfloat invlen = inversesqrt(grad_dot);\n"); 386 if (kHairline == ellipseEffect.getMode()) { 387 // can probably do this with one step 388 builder->fsCodeAppend("\tfloat edgeAlpha = clamp(1.0-test*invlen, 0.0, 1.0);\n"); 389 builder->fsCodeAppend("\tedgeAlpha *= clamp(1.0+test*invlen, 0.0, 1.0);\n"); 390 } else { 391 builder->fsCodeAppend("\tfloat edgeAlpha = clamp(0.5-test*invlen, 0.0, 1.0);\n"); 392 } 393 394 // for inner curve 395 if (kStroke == ellipseEffect.getMode()) { 396 builder->fsCodeAppendf("\tscaledOffset = %s.xy;\n", fsOffsetName1); 397 builder->fsCodeAppend("\ttest = dot(scaledOffset, scaledOffset) - 1.0;\n"); 398 builder->fsCodeAppendf("\tduvdx = dFdx(%s);\n", fsOffsetName1); 399 builder->fsCodeAppendf("\tduvdy = dFdy(%s);\n", fsOffsetName1); 400 builder->fsCodeAppendf("\tgrad = vec2(2.0*%s.x*duvdx.x + 2.0*%s.y*duvdx.y,\n" 401 "\t 2.0*%s.x*duvdy.x + 2.0*%s.y*duvdy.y);\n", 402 fsOffsetName1, fsOffsetName1, fsOffsetName1, fsOffsetName1); 403 builder->fsCodeAppend("\tinvlen = inversesqrt(dot(grad, grad));\n"); 404 builder->fsCodeAppend("\tedgeAlpha *= clamp(0.5+test*invlen, 0.0, 1.0);\n"); 405 } 406 407 builder->fsCodeAppendf("\t%s = %s;\n", outputColor, 408 (GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).c_str()); 409 } 410 411 static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) { 412 const DIEllipseEdgeEffect& ellipseEffect = drawEffect.castEffect<DIEllipseEdgeEffect>(); 413 414 return ellipseEffect.getMode(); 415 } 416 417 virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE { 418 } 419 420 private: 421 typedef GrGLVertexEffect INHERITED; 422 }; 423 424 private: 425 DIEllipseEdgeEffect(Mode mode) : GrVertexEffect() { 426 this->addVertexAttrib(kVec2f_GrSLType); 427 this->addVertexAttrib(kVec2f_GrSLType); 428 fMode = mode; 429 } 430 431 virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE { 432 const DIEllipseEdgeEffect& eee = CastEffect<DIEllipseEdgeEffect>(other); 433 return eee.fMode == fMode; 434 } 435 436 Mode fMode; 437 438 GR_DECLARE_EFFECT_TEST; 439 440 typedef GrVertexEffect INHERITED; 441 }; 442 443 GR_DEFINE_EFFECT_TEST(DIEllipseEdgeEffect); 444 445 GrEffectRef* DIEllipseEdgeEffect::TestCreate(SkRandom* random, 446 GrContext* context, 447 const GrDrawTargetCaps&, 448 GrTexture* textures[]) { 449 return DIEllipseEdgeEffect::Create((Mode)(random->nextRangeU(0,2))); 450 } 451 452 /////////////////////////////////////////////////////////////////////////////// 453 454 void GrOvalRenderer::reset() { 455 SkSafeSetNull(fRRectIndexBuffer); 456 } 457 458 bool GrOvalRenderer::drawOval(GrDrawTarget* target, const GrContext* context, bool useAA, 459 const SkRect& oval, const SkStrokeRec& stroke) 460 { 461 bool useCoverageAA = useAA && 462 !target->getDrawState().getRenderTarget()->isMultisampled() && 463 !target->shouldDisableCoverageAAForBlend(); 464 465 if (!useCoverageAA) { 466 return false; 467 } 468 469 const SkMatrix& vm = context->getMatrix(); 470 471 // we can draw circles 472 if (SkScalarNearlyEqual(oval.width(), oval.height()) 473 && circle_stays_circle(vm)) { 474 this->drawCircle(target, useCoverageAA, oval, stroke); 475 // if we have shader derivative support, render as device-independent 476 } else if (target->caps()->shaderDerivativeSupport()) { 477 return this->drawDIEllipse(target, useCoverageAA, oval, stroke); 478 // otherwise axis-aligned ellipses only 479 } else if (vm.rectStaysRect()) { 480 return this->drawEllipse(target, useCoverageAA, oval, stroke); 481 } else { 482 return false; 483 } 484 485 return true; 486 } 487 488 /////////////////////////////////////////////////////////////////////////////// 489 490 // position + edge 491 extern const GrVertexAttrib gCircleVertexAttribs[] = { 492 {kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBinding}, 493 {kVec4f_GrVertexAttribType, sizeof(GrPoint), kEffect_GrVertexAttribBinding} 494 }; 495 496 void GrOvalRenderer::drawCircle(GrDrawTarget* target, 497 bool useCoverageAA, 498 const SkRect& circle, 499 const SkStrokeRec& stroke) 500 { 501 GrDrawState* drawState = target->drawState(); 502 503 const SkMatrix& vm = drawState->getViewMatrix(); 504 GrPoint center = GrPoint::Make(circle.centerX(), circle.centerY()); 505 vm.mapPoints(¢er, 1); 506 SkScalar radius = vm.mapRadius(SkScalarHalf(circle.width())); 507 SkScalar strokeWidth = vm.mapRadius(stroke.getWidth()); 508 509 GrDrawState::AutoViewMatrixRestore avmr; 510 if (!avmr.setIdentity(drawState)) { 511 return; 512 } 513 514 drawState->setVertexAttribs<gCircleVertexAttribs>(SK_ARRAY_COUNT(gCircleVertexAttribs)); 515 SkASSERT(sizeof(CircleVertex) == drawState->getVertexSize()); 516 517 GrDrawTarget::AutoReleaseGeometry geo(target, 4, 0); 518 if (!geo.succeeded()) { 519 GrPrintf("Failed to get space for vertices!\n"); 520 return; 521 } 522 523 CircleVertex* verts = reinterpret_cast<CircleVertex*>(geo.vertices()); 524 525 SkStrokeRec::Style style = stroke.getStyle(); 526 bool isStroked = (SkStrokeRec::kStroke_Style == style || SkStrokeRec::kHairline_Style == style); 527 528 SkScalar innerRadius = 0.0f; 529 SkScalar outerRadius = radius; 530 SkScalar halfWidth = 0; 531 if (style != SkStrokeRec::kFill_Style) { 532 if (SkScalarNearlyZero(strokeWidth)) { 533 halfWidth = SK_ScalarHalf; 534 } else { 535 halfWidth = SkScalarHalf(strokeWidth); 536 } 537 538 outerRadius += halfWidth; 539 if (isStroked) { 540 innerRadius = radius - halfWidth; 541 } 542 } 543 544 GrEffectRef* effect = CircleEdgeEffect::Create(isStroked && innerRadius > 0); 545 static const int kCircleEdgeAttrIndex = 1; 546 drawState->addCoverageEffect(effect, kCircleEdgeAttrIndex)->unref(); 547 548 // The radii are outset for two reasons. First, it allows the shader to simply perform 549 // clamp(distance-to-center - radius, 0, 1). Second, the outer radius is used to compute the 550 // verts of the bounding box that is rendered and the outset ensures the box will cover all 551 // pixels partially covered by the circle. 552 outerRadius += SK_ScalarHalf; 553 innerRadius -= SK_ScalarHalf; 554 555 SkRect bounds = SkRect::MakeLTRB( 556 center.fX - outerRadius, 557 center.fY - outerRadius, 558 center.fX + outerRadius, 559 center.fY + outerRadius 560 ); 561 562 verts[0].fPos = SkPoint::Make(bounds.fLeft, bounds.fTop); 563 verts[0].fOffset = SkPoint::Make(-outerRadius, -outerRadius); 564 verts[0].fOuterRadius = outerRadius; 565 verts[0].fInnerRadius = innerRadius; 566 567 verts[1].fPos = SkPoint::Make(bounds.fRight, bounds.fTop); 568 verts[1].fOffset = SkPoint::Make(outerRadius, -outerRadius); 569 verts[1].fOuterRadius = outerRadius; 570 verts[1].fInnerRadius = innerRadius; 571 572 verts[2].fPos = SkPoint::Make(bounds.fLeft, bounds.fBottom); 573 verts[2].fOffset = SkPoint::Make(-outerRadius, outerRadius); 574 verts[2].fOuterRadius = outerRadius; 575 verts[2].fInnerRadius = innerRadius; 576 577 verts[3].fPos = SkPoint::Make(bounds.fRight, bounds.fBottom); 578 verts[3].fOffset = SkPoint::Make(outerRadius, outerRadius); 579 verts[3].fOuterRadius = outerRadius; 580 verts[3].fInnerRadius = innerRadius; 581 582 target->drawNonIndexed(kTriangleStrip_GrPrimitiveType, 0, 4, &bounds); 583 } 584 585 /////////////////////////////////////////////////////////////////////////////// 586 587 // position + offset + 1/radii 588 extern const GrVertexAttrib gEllipseVertexAttribs[] = { 589 {kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBinding}, 590 {kVec2f_GrVertexAttribType, sizeof(GrPoint), kEffect_GrVertexAttribBinding}, 591 {kVec4f_GrVertexAttribType, 2*sizeof(GrPoint), kEffect_GrVertexAttribBinding} 592 }; 593 594 // position + offsets 595 extern const GrVertexAttrib gDIEllipseVertexAttribs[] = { 596 {kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBinding}, 597 {kVec2f_GrVertexAttribType, sizeof(GrPoint), kEffect_GrVertexAttribBinding}, 598 {kVec2f_GrVertexAttribType, 2*sizeof(GrPoint), kEffect_GrVertexAttribBinding}, 599 }; 600 601 bool GrOvalRenderer::drawEllipse(GrDrawTarget* target, 602 bool useCoverageAA, 603 const SkRect& ellipse, 604 const SkStrokeRec& stroke) 605 { 606 GrDrawState* drawState = target->drawState(); 607 #ifdef SK_DEBUG 608 { 609 // we should have checked for this previously 610 bool isAxisAlignedEllipse = drawState->getViewMatrix().rectStaysRect(); 611 SkASSERT(useCoverageAA && isAxisAlignedEllipse); 612 } 613 #endif 614 615 // do any matrix crunching before we reset the draw state for device coords 616 const SkMatrix& vm = drawState->getViewMatrix(); 617 GrPoint center = GrPoint::Make(ellipse.centerX(), ellipse.centerY()); 618 vm.mapPoints(¢er, 1); 619 SkScalar ellipseXRadius = SkScalarHalf(ellipse.width()); 620 SkScalar ellipseYRadius = SkScalarHalf(ellipse.height()); 621 SkScalar xRadius = SkScalarAbs(vm[SkMatrix::kMScaleX]*ellipseXRadius + 622 vm[SkMatrix::kMSkewY]*ellipseYRadius); 623 SkScalar yRadius = SkScalarAbs(vm[SkMatrix::kMSkewX]*ellipseXRadius + 624 vm[SkMatrix::kMScaleY]*ellipseYRadius); 625 626 // do (potentially) anisotropic mapping of stroke 627 SkVector scaledStroke; 628 SkScalar strokeWidth = stroke.getWidth(); 629 scaledStroke.fX = SkScalarAbs(strokeWidth*(vm[SkMatrix::kMScaleX] + vm[SkMatrix::kMSkewY])); 630 scaledStroke.fY = SkScalarAbs(strokeWidth*(vm[SkMatrix::kMSkewX] + vm[SkMatrix::kMScaleY])); 631 632 SkStrokeRec::Style style = stroke.getStyle(); 633 bool isStroked = (SkStrokeRec::kStroke_Style == style || SkStrokeRec::kHairline_Style == style); 634 635 SkScalar innerXRadius = 0; 636 SkScalar innerYRadius = 0; 637 if (SkStrokeRec::kFill_Style != style) { 638 if (SkScalarNearlyZero(scaledStroke.length())) { 639 scaledStroke.set(SK_ScalarHalf, SK_ScalarHalf); 640 } else { 641 scaledStroke.scale(SK_ScalarHalf); 642 } 643 644 // we only handle thick strokes for near-circular ellipses 645 if (scaledStroke.length() > SK_ScalarHalf && 646 (SK_ScalarHalf*xRadius > yRadius || SK_ScalarHalf*yRadius > xRadius)) { 647 return false; 648 } 649 650 // we don't handle it if curvature of the stroke is less than curvature of the ellipse 651 if (scaledStroke.fX*(yRadius*yRadius) < (scaledStroke.fY*scaledStroke.fY)*xRadius || 652 scaledStroke.fY*(xRadius*xRadius) < (scaledStroke.fX*scaledStroke.fX)*yRadius) { 653 return false; 654 } 655 656 // this is legit only if scale & translation (which should be the case at the moment) 657 if (isStroked) { 658 innerXRadius = xRadius - scaledStroke.fX; 659 innerYRadius = yRadius - scaledStroke.fY; 660 } 661 662 xRadius += scaledStroke.fX; 663 yRadius += scaledStroke.fY; 664 } 665 666 GrDrawState::AutoViewMatrixRestore avmr; 667 if (!avmr.setIdentity(drawState)) { 668 return false; 669 } 670 671 drawState->setVertexAttribs<gEllipseVertexAttribs>(SK_ARRAY_COUNT(gEllipseVertexAttribs)); 672 SkASSERT(sizeof(EllipseVertex) == drawState->getVertexSize()); 673 674 GrDrawTarget::AutoReleaseGeometry geo(target, 4, 0); 675 if (!geo.succeeded()) { 676 GrPrintf("Failed to get space for vertices!\n"); 677 return false; 678 } 679 680 EllipseVertex* verts = reinterpret_cast<EllipseVertex*>(geo.vertices()); 681 682 GrEffectRef* effect = EllipseEdgeEffect::Create(isStroked && 683 innerXRadius > 0 && innerYRadius > 0); 684 685 static const int kEllipseCenterAttrIndex = 1; 686 static const int kEllipseEdgeAttrIndex = 2; 687 drawState->addCoverageEffect(effect, kEllipseCenterAttrIndex, kEllipseEdgeAttrIndex)->unref(); 688 689 // Compute the reciprocals of the radii here to save time in the shader 690 SkScalar xRadRecip = SkScalarInvert(xRadius); 691 SkScalar yRadRecip = SkScalarInvert(yRadius); 692 SkScalar xInnerRadRecip = SkScalarInvert(innerXRadius); 693 SkScalar yInnerRadRecip = SkScalarInvert(innerYRadius); 694 695 // We've extended the outer x radius out half a pixel to antialias. 696 // This will also expand the rect so all the pixels will be captured. 697 // TODO: Consider if we should use sqrt(2)/2 instead 698 xRadius += SK_ScalarHalf; 699 yRadius += SK_ScalarHalf; 700 701 SkRect bounds = SkRect::MakeLTRB( 702 center.fX - xRadius, 703 center.fY - yRadius, 704 center.fX + xRadius, 705 center.fY + yRadius 706 ); 707 708 verts[0].fPos = SkPoint::Make(bounds.fLeft, bounds.fTop); 709 verts[0].fOffset = SkPoint::Make(-xRadius, -yRadius); 710 verts[0].fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip); 711 verts[0].fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip); 712 713 verts[1].fPos = SkPoint::Make(bounds.fRight, bounds.fTop); 714 verts[1].fOffset = SkPoint::Make(xRadius, -yRadius); 715 verts[1].fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip); 716 verts[1].fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip); 717 718 verts[2].fPos = SkPoint::Make(bounds.fLeft, bounds.fBottom); 719 verts[2].fOffset = SkPoint::Make(-xRadius, yRadius); 720 verts[2].fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip); 721 verts[2].fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip); 722 723 verts[3].fPos = SkPoint::Make(bounds.fRight, bounds.fBottom); 724 verts[3].fOffset = SkPoint::Make(xRadius, yRadius); 725 verts[3].fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip); 726 verts[3].fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip); 727 728 target->drawNonIndexed(kTriangleStrip_GrPrimitiveType, 0, 4, &bounds); 729 730 return true; 731 } 732 733 bool GrOvalRenderer::drawDIEllipse(GrDrawTarget* target, 734 bool useCoverageAA, 735 const SkRect& ellipse, 736 const SkStrokeRec& stroke) 737 { 738 GrDrawState* drawState = target->drawState(); 739 const SkMatrix& vm = drawState->getViewMatrix(); 740 741 GrPoint center = GrPoint::Make(ellipse.centerX(), ellipse.centerY()); 742 SkScalar xRadius = SkScalarHalf(ellipse.width()); 743 SkScalar yRadius = SkScalarHalf(ellipse.height()); 744 745 SkStrokeRec::Style style = stroke.getStyle(); 746 DIEllipseEdgeEffect::Mode mode = (SkStrokeRec::kStroke_Style == style) ? 747 DIEllipseEdgeEffect::kStroke : 748 (SkStrokeRec::kHairline_Style == style) ? 749 DIEllipseEdgeEffect::kHairline : DIEllipseEdgeEffect::kFill; 750 751 SkScalar innerXRadius = 0; 752 SkScalar innerYRadius = 0; 753 if (SkStrokeRec::kFill_Style != style && SkStrokeRec::kHairline_Style != style) { 754 SkScalar strokeWidth = stroke.getWidth(); 755 756 if (SkScalarNearlyZero(strokeWidth)) { 757 strokeWidth = SK_ScalarHalf; 758 } else { 759 strokeWidth *= SK_ScalarHalf; 760 } 761 762 // we only handle thick strokes for near-circular ellipses 763 if (strokeWidth > SK_ScalarHalf && 764 (SK_ScalarHalf*xRadius > yRadius || SK_ScalarHalf*yRadius > xRadius)) { 765 return false; 766 } 767 768 // we don't handle it if curvature of the stroke is less than curvature of the ellipse 769 if (strokeWidth*(yRadius*yRadius) < (strokeWidth*strokeWidth)*xRadius || 770 strokeWidth*(xRadius*xRadius) < (strokeWidth*strokeWidth)*yRadius) { 771 return false; 772 } 773 774 // set inner radius (if needed) 775 if (SkStrokeRec::kStroke_Style == style) { 776 innerXRadius = xRadius - strokeWidth; 777 innerYRadius = yRadius - strokeWidth; 778 } 779 780 xRadius += strokeWidth; 781 yRadius += strokeWidth; 782 } 783 if (DIEllipseEdgeEffect::kStroke == mode) { 784 mode = (innerXRadius > 0 && innerYRadius > 0) ? DIEllipseEdgeEffect::kStroke : 785 DIEllipseEdgeEffect::kFill; 786 } 787 SkScalar innerRatioX = SkScalarDiv(xRadius, innerXRadius); 788 SkScalar innerRatioY = SkScalarDiv(yRadius, innerYRadius); 789 790 drawState->setVertexAttribs<gDIEllipseVertexAttribs>(SK_ARRAY_COUNT(gDIEllipseVertexAttribs)); 791 SkASSERT(sizeof(DIEllipseVertex) == drawState->getVertexSize()); 792 793 GrDrawTarget::AutoReleaseGeometry geo(target, 4, 0); 794 if (!geo.succeeded()) { 795 GrPrintf("Failed to get space for vertices!\n"); 796 return false; 797 } 798 799 DIEllipseVertex* verts = reinterpret_cast<DIEllipseVertex*>(geo.vertices()); 800 801 GrEffectRef* effect = DIEllipseEdgeEffect::Create(mode); 802 803 static const int kEllipseOuterOffsetAttrIndex = 1; 804 static const int kEllipseInnerOffsetAttrIndex = 2; 805 drawState->addCoverageEffect(effect, kEllipseOuterOffsetAttrIndex, 806 kEllipseInnerOffsetAttrIndex)->unref(); 807 808 // This expands the outer rect so that after CTM we end up with a half-pixel border 809 SkScalar a = vm[SkMatrix::kMScaleX]; 810 SkScalar b = vm[SkMatrix::kMSkewX]; 811 SkScalar c = vm[SkMatrix::kMSkewY]; 812 SkScalar d = vm[SkMatrix::kMScaleY]; 813 SkScalar geoDx = SkScalarDiv(SK_ScalarHalf, SkScalarSqrt(a*a + c*c)); 814 SkScalar geoDy = SkScalarDiv(SK_ScalarHalf, SkScalarSqrt(b*b + d*d)); 815 // This adjusts the "radius" to include the half-pixel border 816 SkScalar offsetDx = SkScalarDiv(geoDx, xRadius); 817 SkScalar offsetDy = SkScalarDiv(geoDy, yRadius); 818 819 SkRect bounds = SkRect::MakeLTRB( 820 center.fX - xRadius - geoDx, 821 center.fY - yRadius - geoDy, 822 center.fX + xRadius + geoDx, 823 center.fY + yRadius + geoDy 824 ); 825 826 verts[0].fPos = SkPoint::Make(bounds.fLeft, bounds.fTop); 827 verts[0].fOuterOffset = SkPoint::Make(-1.0f - offsetDx, -1.0f - offsetDy); 828 verts[0].fInnerOffset = SkPoint::Make(-innerRatioX - offsetDx, -innerRatioY - offsetDy); 829 830 verts[1].fPos = SkPoint::Make(bounds.fRight, bounds.fTop); 831 verts[1].fOuterOffset = SkPoint::Make(1.0f + offsetDx, -1.0f - offsetDy); 832 verts[1].fInnerOffset = SkPoint::Make(innerRatioX + offsetDx, -innerRatioY - offsetDy); 833 834 verts[2].fPos = SkPoint::Make(bounds.fLeft, bounds.fBottom); 835 verts[2].fOuterOffset = SkPoint::Make(-1.0f - offsetDx, 1.0f + offsetDy); 836 verts[2].fInnerOffset = SkPoint::Make(-innerRatioX - offsetDx, innerRatioY + offsetDy); 837 838 verts[3].fPos = SkPoint::Make(bounds.fRight, bounds.fBottom); 839 verts[3].fOuterOffset = SkPoint::Make(1.0f + offsetDx, 1.0f + offsetDy); 840 verts[3].fInnerOffset = SkPoint::Make(innerRatioX + offsetDx, innerRatioY + offsetDy); 841 842 target->drawNonIndexed(kTriangleStrip_GrPrimitiveType, 0, 4, &bounds); 843 844 return true; 845 } 846 847 /////////////////////////////////////////////////////////////////////////////// 848 849 static const uint16_t gRRectIndices[] = { 850 // corners 851 0, 1, 5, 0, 5, 4, 852 2, 3, 7, 2, 7, 6, 853 8, 9, 13, 8, 13, 12, 854 10, 11, 15, 10, 15, 14, 855 856 // edges 857 1, 2, 6, 1, 6, 5, 858 4, 5, 9, 4, 9, 8, 859 6, 7, 11, 6, 11, 10, 860 9, 10, 14, 9, 14, 13, 861 862 // center 863 // we place this at the end so that we can ignore these indices when rendering stroke-only 864 5, 6, 10, 5, 10, 9 865 }; 866 867 868 GrIndexBuffer* GrOvalRenderer::rRectIndexBuffer(GrGpu* gpu) { 869 if (NULL == fRRectIndexBuffer) { 870 fRRectIndexBuffer = 871 gpu->createIndexBuffer(sizeof(gRRectIndices), false); 872 if (NULL != fRRectIndexBuffer) { 873 #ifdef SK_DEBUG 874 bool updated = 875 #endif 876 fRRectIndexBuffer->updateData(gRRectIndices, 877 sizeof(gRRectIndices)); 878 GR_DEBUGASSERT(updated); 879 } 880 } 881 return fRRectIndexBuffer; 882 } 883 884 bool GrOvalRenderer::drawSimpleRRect(GrDrawTarget* target, GrContext* context, bool useAA, 885 const SkRRect& rrect, const SkStrokeRec& stroke) 886 { 887 bool useCoverageAA = useAA && 888 !target->getDrawState().getRenderTarget()->isMultisampled() && 889 !target->shouldDisableCoverageAAForBlend(); 890 891 // only anti-aliased rrects for now 892 if (!useCoverageAA) { 893 return false; 894 } 895 896 const SkMatrix& vm = context->getMatrix(); 897 #ifdef SK_DEBUG 898 { 899 // we should have checked for this previously 900 SkASSERT(useCoverageAA && vm.rectStaysRect() && rrect.isSimple()); 901 } 902 #endif 903 904 // do any matrix crunching before we reset the draw state for device coords 905 const SkRect& rrectBounds = rrect.getBounds(); 906 SkRect bounds; 907 vm.mapRect(&bounds, rrectBounds); 908 909 SkVector radii = rrect.getSimpleRadii(); 910 SkScalar xRadius = SkScalarAbs(vm[SkMatrix::kMScaleX]*radii.fX + 911 vm[SkMatrix::kMSkewY]*radii.fY); 912 SkScalar yRadius = SkScalarAbs(vm[SkMatrix::kMSkewX]*radii.fX + 913 vm[SkMatrix::kMScaleY]*radii.fY); 914 915 // if hairline stroke is greater than radius, we don't handle that right now 916 SkStrokeRec::Style style = stroke.getStyle(); 917 if (SkStrokeRec::kHairline_Style == style && 918 (SK_ScalarHalf > xRadius || SK_ScalarHalf > yRadius)) { 919 return false; 920 } 921 922 // do (potentially) anisotropic mapping of stroke 923 SkVector scaledStroke; 924 SkScalar strokeWidth = stroke.getWidth(); 925 scaledStroke.fX = SkScalarAbs(strokeWidth*(vm[SkMatrix::kMScaleX] + vm[SkMatrix::kMSkewY])); 926 scaledStroke.fY = SkScalarAbs(strokeWidth*(vm[SkMatrix::kMSkewX] + vm[SkMatrix::kMScaleY])); 927 928 // if half of strokewidth is greater than radius, we don't handle that right now 929 if (SK_ScalarHalf*scaledStroke.fX > xRadius || SK_ScalarHalf*scaledStroke.fY > yRadius) { 930 return false; 931 } 932 933 // reset to device coordinates 934 GrDrawState* drawState = target->drawState(); 935 GrDrawState::AutoViewMatrixRestore avmr; 936 if (!avmr.setIdentity(drawState)) { 937 return false; 938 } 939 940 bool isStroked = (SkStrokeRec::kStroke_Style == style || SkStrokeRec::kHairline_Style == style); 941 942 GrIndexBuffer* indexBuffer = this->rRectIndexBuffer(context->getGpu()); 943 if (NULL == indexBuffer) { 944 GrPrintf("Failed to create index buffer!\n"); 945 return false; 946 } 947 948 // if the corners are circles, use the circle renderer 949 if ((!isStroked || scaledStroke.fX == scaledStroke.fY) && xRadius == yRadius) { 950 drawState->setVertexAttribs<gCircleVertexAttribs>(SK_ARRAY_COUNT(gCircleVertexAttribs)); 951 SkASSERT(sizeof(CircleVertex) == drawState->getVertexSize()); 952 953 GrDrawTarget::AutoReleaseGeometry geo(target, 16, 0); 954 if (!geo.succeeded()) { 955 GrPrintf("Failed to get space for vertices!\n"); 956 return false; 957 } 958 CircleVertex* verts = reinterpret_cast<CircleVertex*>(geo.vertices()); 959 960 SkScalar innerRadius = 0.0f; 961 SkScalar outerRadius = xRadius; 962 SkScalar halfWidth = 0; 963 if (style != SkStrokeRec::kFill_Style) { 964 if (SkScalarNearlyZero(scaledStroke.fX)) { 965 halfWidth = SK_ScalarHalf; 966 } else { 967 halfWidth = SkScalarHalf(scaledStroke.fX); 968 } 969 970 if (isStroked) { 971 innerRadius = xRadius - halfWidth; 972 } 973 outerRadius += halfWidth; 974 bounds.outset(halfWidth, halfWidth); 975 } 976 977 isStroked = (isStroked && innerRadius >= 0); 978 979 GrEffectRef* effect = CircleEdgeEffect::Create(isStroked); 980 static const int kCircleEdgeAttrIndex = 1; 981 drawState->addCoverageEffect(effect, kCircleEdgeAttrIndex)->unref(); 982 983 // The radii are outset for two reasons. First, it allows the shader to simply perform 984 // clamp(distance-to-center - radius, 0, 1). Second, the outer radius is used to compute the 985 // verts of the bounding box that is rendered and the outset ensures the box will cover all 986 // pixels partially covered by the circle. 987 outerRadius += SK_ScalarHalf; 988 innerRadius -= SK_ScalarHalf; 989 990 // Expand the rect so all the pixels will be captured. 991 bounds.outset(SK_ScalarHalf, SK_ScalarHalf); 992 993 SkScalar yCoords[4] = { 994 bounds.fTop, 995 bounds.fTop + outerRadius, 996 bounds.fBottom - outerRadius, 997 bounds.fBottom 998 }; 999 SkScalar yOuterRadii[4] = { 1000 -outerRadius, 1001 0, 1002 0, 1003 outerRadius 1004 }; 1005 for (int i = 0; i < 4; ++i) { 1006 verts->fPos = SkPoint::Make(bounds.fLeft, yCoords[i]); 1007 verts->fOffset = SkPoint::Make(-outerRadius, yOuterRadii[i]); 1008 verts->fOuterRadius = outerRadius; 1009 verts->fInnerRadius = innerRadius; 1010 verts++; 1011 1012 verts->fPos = SkPoint::Make(bounds.fLeft + outerRadius, yCoords[i]); 1013 verts->fOffset = SkPoint::Make(0, yOuterRadii[i]); 1014 verts->fOuterRadius = outerRadius; 1015 verts->fInnerRadius = innerRadius; 1016 verts++; 1017 1018 verts->fPos = SkPoint::Make(bounds.fRight - outerRadius, yCoords[i]); 1019 verts->fOffset = SkPoint::Make(0, yOuterRadii[i]); 1020 verts->fOuterRadius = outerRadius; 1021 verts->fInnerRadius = innerRadius; 1022 verts++; 1023 1024 verts->fPos = SkPoint::Make(bounds.fRight, yCoords[i]); 1025 verts->fOffset = SkPoint::Make(outerRadius, yOuterRadii[i]); 1026 verts->fOuterRadius = outerRadius; 1027 verts->fInnerRadius = innerRadius; 1028 verts++; 1029 } 1030 1031 // drop out the middle quad if we're stroked 1032 int indexCnt = isStroked ? GR_ARRAY_COUNT(gRRectIndices)-6 : GR_ARRAY_COUNT(gRRectIndices); 1033 target->setIndexSourceToBuffer(indexBuffer); 1034 target->drawIndexed(kTriangles_GrPrimitiveType, 0, 0, 16, indexCnt, &bounds); 1035 1036 // otherwise we use the ellipse renderer 1037 } else { 1038 drawState->setVertexAttribs<gEllipseVertexAttribs>(SK_ARRAY_COUNT(gEllipseVertexAttribs)); 1039 SkASSERT(sizeof(EllipseVertex) == drawState->getVertexSize()); 1040 1041 SkScalar innerXRadius = 0.0f; 1042 SkScalar innerYRadius = 0.0f; 1043 if (SkStrokeRec::kFill_Style != style) { 1044 if (SkScalarNearlyZero(scaledStroke.length())) { 1045 scaledStroke.set(SK_ScalarHalf, SK_ScalarHalf); 1046 } else { 1047 scaledStroke.scale(SK_ScalarHalf); 1048 } 1049 1050 // we only handle thick strokes for near-circular ellipses 1051 if (scaledStroke.length() > SK_ScalarHalf && 1052 (SK_ScalarHalf*xRadius > yRadius || SK_ScalarHalf*yRadius > xRadius)) { 1053 return false; 1054 } 1055 1056 // we don't handle it if curvature of the stroke is less than curvature of the ellipse 1057 if (scaledStroke.fX*(yRadius*yRadius) < (scaledStroke.fY*scaledStroke.fY)*xRadius || 1058 scaledStroke.fY*(xRadius*xRadius) < (scaledStroke.fX*scaledStroke.fX)*yRadius) { 1059 return false; 1060 } 1061 1062 // this is legit only if scale & translation (which should be the case at the moment) 1063 if (isStroked) { 1064 innerXRadius = xRadius - scaledStroke.fX; 1065 innerYRadius = yRadius - scaledStroke.fY; 1066 } 1067 1068 xRadius += scaledStroke.fX; 1069 yRadius += scaledStroke.fY; 1070 bounds.outset(scaledStroke.fX, scaledStroke.fY); 1071 } 1072 1073 isStroked = (isStroked && innerXRadius >= 0 && innerYRadius >= 0); 1074 1075 GrDrawTarget::AutoReleaseGeometry geo(target, 16, 0); 1076 if (!geo.succeeded()) { 1077 GrPrintf("Failed to get space for vertices!\n"); 1078 return false; 1079 } 1080 EllipseVertex* verts = reinterpret_cast<EllipseVertex*>(geo.vertices()); 1081 1082 GrEffectRef* effect = EllipseEdgeEffect::Create(isStroked); 1083 static const int kEllipseOffsetAttrIndex = 1; 1084 static const int kEllipseRadiiAttrIndex = 2; 1085 drawState->addCoverageEffect(effect, 1086 kEllipseOffsetAttrIndex, kEllipseRadiiAttrIndex)->unref(); 1087 1088 // Compute the reciprocals of the radii here to save time in the shader 1089 SkScalar xRadRecip = SkScalarInvert(xRadius); 1090 SkScalar yRadRecip = SkScalarInvert(yRadius); 1091 SkScalar xInnerRadRecip = SkScalarInvert(innerXRadius); 1092 SkScalar yInnerRadRecip = SkScalarInvert(innerYRadius); 1093 1094 // Extend the radii out half a pixel to antialias. 1095 SkScalar xOuterRadius = xRadius + SK_ScalarHalf; 1096 SkScalar yOuterRadius = yRadius + SK_ScalarHalf; 1097 1098 // Expand the rect so all the pixels will be captured. 1099 bounds.outset(SK_ScalarHalf, SK_ScalarHalf); 1100 1101 SkScalar yCoords[4] = { 1102 bounds.fTop, 1103 bounds.fTop + yOuterRadius, 1104 bounds.fBottom - yOuterRadius, 1105 bounds.fBottom 1106 }; 1107 SkScalar yOuterOffsets[4] = { 1108 yOuterRadius, 1109 SK_ScalarNearlyZero, // we're using inversesqrt() in the shader, so can't be exactly 0 1110 SK_ScalarNearlyZero, 1111 yOuterRadius 1112 }; 1113 1114 for (int i = 0; i < 4; ++i) { 1115 verts->fPos = SkPoint::Make(bounds.fLeft, yCoords[i]); 1116 verts->fOffset = SkPoint::Make(xOuterRadius, yOuterOffsets[i]); 1117 verts->fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip); 1118 verts->fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip); 1119 verts++; 1120 1121 verts->fPos = SkPoint::Make(bounds.fLeft + xOuterRadius, yCoords[i]); 1122 verts->fOffset = SkPoint::Make(SK_ScalarNearlyZero, yOuterOffsets[i]); 1123 verts->fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip); 1124 verts->fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip); 1125 verts++; 1126 1127 verts->fPos = SkPoint::Make(bounds.fRight - xOuterRadius, yCoords[i]); 1128 verts->fOffset = SkPoint::Make(SK_ScalarNearlyZero, yOuterOffsets[i]); 1129 verts->fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip); 1130 verts->fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip); 1131 verts++; 1132 1133 verts->fPos = SkPoint::Make(bounds.fRight, yCoords[i]); 1134 verts->fOffset = SkPoint::Make(xOuterRadius, yOuterOffsets[i]); 1135 verts->fOuterRadii = SkPoint::Make(xRadRecip, yRadRecip); 1136 verts->fInnerRadii = SkPoint::Make(xInnerRadRecip, yInnerRadRecip); 1137 verts++; 1138 } 1139 1140 // drop out the middle quad if we're stroked 1141 int indexCnt = isStroked ? GR_ARRAY_COUNT(gRRectIndices)-6 : GR_ARRAY_COUNT(gRRectIndices); 1142 target->setIndexSourceToBuffer(indexBuffer); 1143 target->drawIndexed(kTriangles_GrPrimitiveType, 0, 0, 16, indexCnt, &bounds); 1144 } 1145 1146 return true; 1147 } 1148
