/// draw state is left unmodified.
GrDrawTarget* prepareToDraw(const GrPaint*, BufferedDraw);
- void internalDrawPath(GrDrawTarget* target, const GrPaint& paint, const SkPath& path,
+ void internalDrawPath(GrDrawTarget* target, bool useAA, const SkPath& path,
const SkStrokeRec& stroke);
GrTexture* createResizedTexture(const GrTextureDesc& desc,
GrOvalRenderer() : fRRectIndexBuffer(NULL) {}
~GrOvalRenderer() {}
- bool drawOval(GrDrawTarget* target, const GrContext* context, const GrPaint& paint,
+ bool drawOval(GrDrawTarget* target, const GrContext* context, bool useAA,
const GrRect& oval, const SkStrokeRec& stroke);
- bool drawSimpleRRect(GrDrawTarget* target, GrContext* context, const GrPaint& paint,
+ bool drawSimpleRRect(GrDrawTarget* target, GrContext* context, bool useAA,
const SkRRect& rrect, const SkStrokeRec& stroke);
private:
- bool drawEllipse(GrDrawTarget* target, const GrPaint& paint,
+ bool drawEllipse(GrDrawTarget* target, bool useAA,
const GrRect& ellipse,
const SkStrokeRec& stroke);
- void drawCircle(GrDrawTarget* target, const GrPaint& paint,
+ void drawCircle(GrDrawTarget* target, bool useAA,
const GrRect& circle,
const SkStrokeRec& stroke);
GrDrawTarget* target = this->prepareToDraw(&paint, BUFFERED_DRAW);
GrDrawState::AutoStageDisable atr(fDrawState);
- if (!fOvalRenderer->drawSimpleRRect(target, this, paint, rect, stroke)) {
+ bool prAA = paint.isAntiAlias() && !this->getRenderTarget()->isMultisampled();
+
+ if (!fOvalRenderer->drawSimpleRRect(target, this, prAA, rect, stroke)) {
SkPath path;
path.addRRect(rect);
- this->internalDrawPath(target, paint, path, stroke);
+ this->internalDrawPath(target, prAA, path, stroke);
}
}
GrDrawTarget* target = this->prepareToDraw(&paint, BUFFERED_DRAW);
GrDrawState::AutoStageDisable atr(fDrawState);
- if (!fOvalRenderer->drawOval(target, this, paint, oval, stroke)) {
+ bool useAA = paint.isAntiAlias() && !this->getRenderTarget()->isMultisampled();
+
+ if (!fOvalRenderer->drawOval(target, this, useAA, oval, stroke)) {
SkPath path;
path.addOval(oval);
- this->internalDrawPath(target, paint, path, stroke);
+ this->internalDrawPath(target, useAA, path, stroke);
}
}
SkRect ovalRect;
bool isOval = path.isOval(&ovalRect);
+ bool useAA = paint.isAntiAlias() && !this->getRenderTarget()->isMultisampled();
if (!isOval || path.isInverseFillType()
- || !fOvalRenderer->drawOval(target, this, paint, ovalRect, stroke)) {
- this->internalDrawPath(target, paint, path, stroke);
+ || !fOvalRenderer->drawOval(target, this, useAA, ovalRect, stroke)) {
+ this->internalDrawPath(target, useAA, path, stroke);
}
}
-void GrContext::internalDrawPath(GrDrawTarget* target, const GrPaint& paint, const SkPath& path,
+void GrContext::internalDrawPath(GrDrawTarget* target, bool useAA, const SkPath& path,
const SkStrokeRec& stroke) {
- bool prAA = paint.isAntiAlias() && !this->getRenderTarget()->isMultisampled();
-
// An Assumption here is that path renderer would use some form of tweaking
// the src color (either the input alpha or in the frag shader) to implement
// aa. If we have some future driver-mojo path AA that can do the right
#if GR_DEBUG
//GrPrintf("Turning off AA to correctly apply blend.\n");
#endif
- prAA = false;
+ useAA = false;
}
- GrPathRendererChain::DrawType type = prAA ? GrPathRendererChain::kColorAntiAlias_DrawType :
- GrPathRendererChain::kColor_DrawType;
+ GrPathRendererChain::DrawType type = useAA ? GrPathRendererChain::kColorAntiAlias_DrawType :
+ GrPathRendererChain::kColor_DrawType;
const SkPath* pathPtr = &path;
SkPath tmpPath;
return;
}
- pr->drawPath(*pathPtr, strokeRec, target, prAA);
+ pr->drawPath(*pathPtr, strokeRec, target, useAA);
}
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
-bool GrOvalRenderer::drawOval(GrDrawTarget* target, const GrContext* context, const GrPaint& paint,
- const GrRect& oval, const SkStrokeRec& stroke)
+bool GrOvalRenderer::drawOval(GrDrawTarget* target, const GrContext* context, bool useAA,
+ const GrRect& oval, const SkStrokeRec& stroke)
{
- if (!paint.isAntiAlias()) {
+ if (!useAA) {
return false;
}
// we can draw circles
if (SkScalarNearlyEqual(oval.width(), oval.height())
&& circle_stays_circle(vm)) {
- drawCircle(target, paint, oval, stroke);
+ this->drawCircle(target, useAA, oval, stroke);
// and axis-aligned ellipses only
} else if (vm.rectStaysRect()) {
- return drawEllipse(target, paint, oval, stroke);
+ return this->drawEllipse(target, useAA, oval, stroke);
} else {
return false;
};
void GrOvalRenderer::drawCircle(GrDrawTarget* target,
- const GrPaint& paint,
+ bool useAA,
const GrRect& circle,
const SkStrokeRec& stroke)
{
};
bool GrOvalRenderer::drawEllipse(GrDrawTarget* target,
- const GrPaint& paint,
+ bool useAA,
const GrRect& ellipse,
const SkStrokeRec& stroke)
{
{
// we should have checked for this previously
bool isAxisAlignedEllipse = drawState->getViewMatrix().rectStaysRect();
- SkASSERT(paint.isAntiAlias() && isAxisAlignedEllipse);
+ SkASSERT(useAA && isAxisAlignedEllipse);
}
#endif
return fRRectIndexBuffer;
}
-bool GrOvalRenderer::drawSimpleRRect(GrDrawTarget* target, GrContext* context,
- const GrPaint& paint, const SkRRect& rrect,
- const SkStrokeRec& stroke)
+bool GrOvalRenderer::drawSimpleRRect(GrDrawTarget* target, GrContext* context, bool useAA,
+ const SkRRect& rrect, const SkStrokeRec& stroke)
{
+ // only anti-aliased rrects for now
+ if (!useAA) {
+ return false;
+ }
+
const SkMatrix& vm = context->getMatrix();
#ifdef SK_DEBUG
{
// we should have checked for this previously
- SkASSERT(paint.isAntiAlias() && vm.rectStaysRect() && rrect.isSimple());
+ SkASSERT(useAA && vm.rectStaysRect() && rrect.isSimple());
}
#endif
CHECK_FOR_NODRAW_ANNOTATION(paint);
CHECK_SHOULD_DRAW(draw, false);
- bool usePath = !rect.isSimple() || !paint.isAntiAlias();
+ bool usePath = !rect.isSimple();
// another two reasons we might need to call drawPath...
if (paint.getMaskFilter() || paint.getPathEffect()) {
usePath = true;