diff options
76 files changed, 621 insertions, 680 deletions
diff --git a/gm/beziereffects.cpp b/gm/beziereffects.cpp index 9a1990b383..f924ee070a 100644 --- a/gm/beziereffects.cpp +++ b/gm/beziereffects.cpp @@ -195,8 +195,7 @@ protected: sk_sp<GrDrawOp> batch = sk_make_sp<BezierCubicOrConicTestBatch>( gp, bounds, color, klmEqs, klmSigns[c]); - renderTargetContext->priv().testingOnly_drawBatch(grPaint, GrAAType::kNone, - batch.get()); + renderTargetContext->priv().testingOnly_drawBatch(grPaint, batch.get()); } ++col; if (numCols == col) { @@ -328,8 +327,7 @@ protected: sk_sp<GrDrawOp> batch( new BezierCubicOrConicTestBatch(gp, bounds, color, klmEqs, 1.f)); - renderTargetContext->priv().testingOnly_drawBatch(grPaint, GrAAType::kNone, - batch.get()); + renderTargetContext->priv().testingOnly_drawBatch(grPaint, batch.get()); } ++col; if (numCols == col) { @@ -540,8 +538,7 @@ protected: sk_sp<GrDrawOp> batch(new BezierQuadTestBatch(gp, bounds, color, DevToUV)); - renderTargetContext->priv().testingOnly_drawBatch(grPaint, GrAAType::kNone, - batch.get()); + renderTargetContext->priv().testingOnly_drawBatch(grPaint, batch.get()); } ++col; if (numCols == col) { diff --git a/gm/bigrrectaaeffect.cpp b/gm/bigrrectaaeffect.cpp index 9750d90197..b114f49fa4 100644 --- a/gm/bigrrectaaeffect.cpp +++ b/gm/bigrrectaaeffect.cpp @@ -90,8 +90,7 @@ protected: sk_sp<GrDrawOp> batch( GrRectBatchFactory::CreateNonAAFill(0xff000000, SkMatrix::I(), bounds, nullptr, nullptr)); - renderTargetContext->priv().testingOnly_drawBatch(grPaint, GrAAType::kNone, - batch.get()); + renderTargetContext->priv().testingOnly_drawBatch(grPaint, batch.get()); } canvas->restore(); x = x + fTestOffsetX; diff --git a/gm/constcolorprocessor.cpp b/gm/constcolorprocessor.cpp index 67b2b33e19..d70674279c 100644 --- a/gm/constcolorprocessor.cpp +++ b/gm/constcolorprocessor.cpp @@ -112,8 +112,7 @@ protected: sk_sp<GrDrawOp> batch( GrRectBatchFactory::CreateNonAAFill(grPaint.getColor(), viewMatrix, renderRect, nullptr, nullptr)); - renderTargetContext->priv().testingOnly_drawBatch(grPaint, GrAAType::kNone, - batch.get()); + renderTargetContext->priv().testingOnly_drawBatch(grPaint, batch.get()); // Draw labels for the input to the processor and the processor to the right of // the test rect. The input label appears above the processor label. diff --git a/gm/convexpolyeffect.cpp b/gm/convexpolyeffect.cpp index c7a5d0c7f1..7a8c5b292a 100644 --- a/gm/convexpolyeffect.cpp +++ b/gm/convexpolyeffect.cpp @@ -185,8 +185,7 @@ protected: sk_sp<GrDrawOp> batch(new PolyBoundsBatch(p.getBounds(), 0xff000000)); - renderTargetContext->priv().testingOnly_drawBatch(grPaint, GrAAType::kNone, - batch.get()); + renderTargetContext->priv().testingOnly_drawBatch(grPaint, batch.get()); x += SkScalarCeilToScalar(path->getBounds().width() + kDX); } @@ -225,8 +224,7 @@ protected: sk_sp<GrDrawOp> batch(new PolyBoundsBatch(rect, 0xff000000)); - renderTargetContext->priv().testingOnly_drawBatch(grPaint, GrAAType::kNone, - batch.get()); + renderTargetContext->priv().testingOnly_drawBatch(grPaint, batch.get()); x += SkScalarCeilToScalar(rect.width() + kDX); } diff --git a/gm/rrects.cpp b/gm/rrects.cpp index a3b31d55ca..268e449319 100644 --- a/gm/rrects.cpp +++ b/gm/rrects.cpp @@ -118,9 +118,7 @@ protected: sk_sp<GrDrawOp> batch( GrRectBatchFactory::CreateNonAAFill(0xff000000, SkMatrix::I(), bounds, nullptr, nullptr)); - renderTargetContext->priv().testingOnly_drawBatch(grPaint, - GrAAType::kNone, - batch.get()); + renderTargetContext->priv().testingOnly_drawBatch(grPaint, batch.get()); } else { drew = false; } diff --git a/gm/texdata.cpp b/gm/texdata.cpp index 574dfad2be..4a74468ac5 100644 --- a/gm/texdata.cpp +++ b/gm/texdata.cpp @@ -102,7 +102,7 @@ DEF_SIMPLE_GM_BG(texdata, canvas, 2 * S, 2 * S, SK_ColorBLACK) { tm.postIDiv(2*S, 2*S); paint.addColorTextureProcessor(texture, nullptr, tm); - renderTargetContext->drawRect(clip, paint, GrAA::kNo, vm, SkRect::MakeWH(2*S, 2*S)); + renderTargetContext->drawRect(clip, paint, vm, SkRect::MakeWH(2*S, 2*S)); // now update the lower right of the texture in first pass // or upper right in second pass @@ -116,7 +116,7 @@ DEF_SIMPLE_GM_BG(texdata, canvas, 2 * S, 2 * S, SK_ColorBLACK) { texture->writePixels(S, (i ? 0 : S), S, S, texture->config(), gTextureData.get(), 4 * stride); - renderTargetContext->drawRect(clip, paint, GrAA::kNo, vm, SkRect::MakeWH(2*S, 2*S)); + renderTargetContext->drawRect(clip, paint, vm, SkRect::MakeWH(2*S, 2*S)); } } #endif diff --git a/gm/texturedomaineffect.cpp b/gm/texturedomaineffect.cpp index 5ce6017815..e51a9065be 100644 --- a/gm/texturedomaineffect.cpp +++ b/gm/texturedomaineffect.cpp @@ -130,8 +130,7 @@ protected: sk_sp<GrDrawOp> batch( GrRectBatchFactory::CreateNonAAFill(GrColor_WHITE, viewMatrix, renderRect, nullptr, nullptr)); - renderTargetContext->priv().testingOnly_drawBatch(grPaint, GrAAType::kNone, - batch.get()); + renderTargetContext->priv().testingOnly_drawBatch(grPaint, batch.get()); x += renderRect.width() + kTestPad; } y += renderRect.height() + kTestPad; diff --git a/gm/windowrectangles.cpp b/gm/windowrectangles.cpp index e16392b423..e277db626c 100644 --- a/gm/windowrectangles.cpp +++ b/gm/windowrectangles.cpp @@ -141,7 +141,7 @@ private: class MaskOnlyClipBase : public GrClip { private: bool quickContains(const SkRect&) const final { return false; } - bool isRRect(const SkRect& rtBounds, SkRRect* rr, GrAA*) const final { return false; } + bool isRRect(const SkRect& rtBounds, SkRRect* rr, bool* aa) const final { return false; } void getConservativeBounds(int width, int height, SkIRect* rect, bool* iior) const final { rect->set(0, 0, width, height); if (iior) { @@ -190,6 +190,7 @@ void WindowRectanglesMaskGM::onCoverClipStack(const SkClipStack& stack, SkCanvas const GrReducedClip reducedClip(stack, SkRect::Make(kCoverRect), kNumWindows); GrPaint paint; + paint.setAntiAlias(true); if (!rtc->isStencilBufferMultisampled()) { paint.setColor4f(GrColor4f(0, 0.25f, 1, 1)); this->visualizeAlphaMask(ctx, rtc, reducedClip, paint); @@ -216,7 +217,7 @@ void WindowRectanglesMaskGM::visualizeAlphaMask(GrContext* ctx, GrRenderTargetCo this->stencilCheckerboard(maskRTC.get(), true); maskRTC->clear(nullptr, GrColorPackA4(0xff), true); maskRTC->priv().drawAndStencilRect(StencilOnlyClip(), &GrUserStencilSettings::kUnused, - SkRegion::kDifference_Op, false, GrAA::kNo, SkMatrix::I(), + SkRegion::kDifference_Op, false, false, SkMatrix::I(), SkRect::MakeIWH(maskRTC->width(), maskRTC->height())); reducedClip.drawAlphaClipMask(maskRTC.get()); sk_sp<GrTexture> mask(maskRTC->asTexture()); @@ -228,7 +229,7 @@ void WindowRectanglesMaskGM::visualizeAlphaMask(GrContext* ctx, GrRenderTargetCo // inside window rectangles or outside the scissor should still have the initial checkerboard // intact. (This verifies we didn't spend any time modifying those pixels in the mask.) AlphaOnlyClip clip(mask.get(), x, y); - rtc->drawRect(clip, paint, GrAA::kYes, SkMatrix::I(), + rtc->drawRect(clip, paint, SkMatrix::I(), SkRect::Make(SkIRect::MakeXYWH(x, y, mask->width(), mask->height()))); } @@ -267,7 +268,7 @@ void WindowRectanglesMaskGM::stencilCheckerboard(GrRenderTargetContext* rtc, boo for (int x = (y & 1) == flip ? 0 : kMaskCheckerSize; x < kLayerRect.width(); x += 2 * kMaskCheckerSize) { SkIRect checker = SkIRect::MakeXYWH(x, y, kMaskCheckerSize, kMaskCheckerSize); - rtc->priv().stencilRect(GrNoClip(), &kSetClip, GrAAType::kNone, SkMatrix::I(), + rtc->priv().stencilRect(GrNoClip(), &kSetClip, false, SkMatrix::I(), SkRect::Make(checker)); } } diff --git a/gm/yuvtorgbeffect.cpp b/gm/yuvtorgbeffect.cpp index fb0bcf3cfa..6b90dad9cc 100644 --- a/gm/yuvtorgbeffect.cpp +++ b/gm/yuvtorgbeffect.cpp @@ -129,8 +129,7 @@ protected: sk_sp<GrDrawOp> batch( GrRectBatchFactory::CreateNonAAFill(GrColor_WHITE, viewMatrix, renderRect, nullptr, nullptr)); - renderTargetContext->priv().testingOnly_drawBatch(grPaint, GrAAType::kNone, - batch.get()); + renderTargetContext->priv().testingOnly_drawBatch(grPaint, batch.get()); } x += renderRect.width() + kTestPad; } @@ -245,8 +244,7 @@ protected: grPaint.addColorFragmentProcessor(fp); sk_sp<GrDrawOp> batch(GrRectBatchFactory::CreateNonAAFill( GrColor_WHITE, viewMatrix, renderRect, nullptr, nullptr)); - renderTargetContext->priv().testingOnly_drawBatch(grPaint, GrAAType::kNone, - batch.get()); + renderTargetContext->priv().testingOnly_drawBatch(grPaint, batch.get()); } } } diff --git a/include/gpu/GrClip.h b/include/gpu/GrClip.h index 9bf2da205e..2d4c1f2628 100644 --- a/include/gpu/GrClip.h +++ b/include/gpu/GrClip.h @@ -8,7 +8,6 @@ #ifndef GrClip_DEFINED #define GrClip_DEFINED -#include "GrTypes.h" #include "SkRect.h" #include "SkRRect.h" @@ -46,7 +45,7 @@ public: * @return true if the clip is equivalent to a single rrect, false otherwise. * */ - virtual bool isRRect(const SkRect& rtBounds, SkRRect* rrect, GrAA* aa) const = 0; + virtual bool isRRect(const SkRect& rtBounds, SkRRect* rrect, bool* aa) const = 0; /** * This is the maximum distance that a draw may extend beyond a clip's boundary and still count @@ -141,7 +140,7 @@ private: bool apply(GrContext*, GrRenderTargetContext*, bool, bool, GrAppliedClip*) const final { return true; } - bool isRRect(const SkRect&, SkRRect*, GrAA*) const override { return false; } + bool isRRect(const SkRect&, SkRRect*, bool*) const override { return false; } }; #endif diff --git a/include/gpu/GrPaint.h b/include/gpu/GrPaint.h index 6cdc2de09c..9390d021a3 100644 --- a/include/gpu/GrPaint.h +++ b/include/gpu/GrPaint.h @@ -30,9 +30,10 @@ * The primitive color computation starts with the color specified by setColor(). This color is the * input to the first color stage. Each color stage feeds its output to the next color stage. * - * Fractional pixel coverage follows a similar flow. The GrGeometryProcessor (specified elsewhere) - * provides the initial coverage which is passed to the first coverage fragment processor, which - * feeds its output to next coverage fragment processor. + * Fractional pixel coverage follows a similar flow. The coverage is initially the value specified + * by setCoverage(). This is input to the first coverage stage. Coverage stages are chained + * together in the same manner as color stages. The output of the last stage is modulated by any + * fractional coverage produced by anti-aliasing. This last step produces the final coverage, C. * * setXPFactory is used to control blending between the output color and dest. It also implements * the application of fractional coverage from the coverage pipeline. @@ -57,6 +58,12 @@ public: GrColor getColor() const { return fColor.toGrColor(); } /** + * Should primitives be anti-aliased or not. Defaults to false. + */ + void setAntiAlias(bool aa) { fAntiAlias = aa; } + bool isAntiAlias() const { return fAntiAlias; } + + /** * Should shader output conversion from linear to sRGB be disabled. * Only relevant if the destination is sRGB. Defaults to false. */ @@ -139,6 +146,7 @@ public: } GrPaint& operator=(const GrPaint& paint) { + fAntiAlias = paint.fAntiAlias; fDisableOutputConversionToSRGB = paint.fDisableOutputConversionToSRGB; fAllowSRGBInputs = paint.fAllowSRGBInputs; fUsesDistanceVectorField = paint.fUsesDistanceVectorField; @@ -177,6 +185,7 @@ private: SkSTArray<4, sk_sp<GrFragmentProcessor>> fColorFragmentProcessors; SkSTArray<2, sk_sp<GrFragmentProcessor>> fCoverageFragmentProcessors; + bool fAntiAlias; bool fDisableOutputConversionToSRGB; bool fAllowSRGBInputs; bool fUsesDistanceVectorField; diff --git a/include/gpu/GrRenderTargetContext.h b/include/gpu/GrRenderTargetContext.h index d958ba2761..7ef572abce 100644 --- a/include/gpu/GrRenderTargetContext.h +++ b/include/gpu/GrRenderTargetContext.h @@ -88,17 +88,15 @@ public: void drawPaint(const GrClip&, const GrPaint&, const SkMatrix& viewMatrix); /** - * Draw the rect using a paint. - * @param paint describes how to color pixels. - * @param GrAA Controls whether rect is antialiased - * @param viewMatrix transformation matrix - * @param style The style to apply. Null means fill. Currently path effects are not - * allowed. - * The rects coords are used to access the paint (through texture matrix) + * Draw the rect using a paint. + * @param paint describes how to color pixels. + * @param viewMatrix transformation matrix + * @param style The style to apply. Null means fill. Currently path effects are not + * allowed. + * The rects coords are used to access the paint (through texture matrix) */ void drawRect(const GrClip&, const GrPaint& paint, - GrAA, const SkMatrix& viewMatrix, const SkRect&, const GrStyle* style = nullptr); @@ -106,15 +104,13 @@ public: /** * Maps a rectangle of shader coordinates to a rectangle and fills that rectangle. * - * @param paint describes how to color pixels. - * @param GrAA Controls whether rect is antialiased - * @param viewMatrix transformation matrix which applies to rectToDraw - * @param rectToDraw the rectangle to draw - * @param localRect the rectangle of shader coordinates applied to rectToDraw + * @param paint describes how to color pixels. + * @param viewMatrix transformation matrix which applies to rectToDraw + * @param rectToDraw the rectangle to draw + * @param localRect the rectangle of shader coordinates applied to rectToDraw */ void fillRectToRect(const GrClip&, const GrPaint& paint, - GrAA, const SkMatrix& viewMatrix, const SkRect& rectToDraw, const SkRect& localRect); @@ -124,36 +120,33 @@ public: */ void fillRectWithLocalMatrix(const GrClip& clip, const GrPaint& paint, - GrAA, const SkMatrix& viewMatrix, const SkRect& rect, const SkMatrix& localMatrix); /** - * Draw a roundrect using a paint. + * Draw a roundrect using a paint. * - * @param paint describes how to color pixels. - * @param GrAA Controls whether rrect is antialiased. - * @param viewMatrix transformation matrix - * @param rrect the roundrect to draw - * @param style style to apply to the rrect. Currently path effects are not allowed. + * @param paint describes how to color pixels. + * @param viewMatrix transformation matrix + * @param rrect the roundrect to draw + * @param style style to apply to the rrect. Currently path effects are not allowed. */ void drawRRect(const GrClip&, const GrPaint&, - GrAA, const SkMatrix& viewMatrix, const SkRRect& rrect, const GrStyle& style); /** - * Draw a roundrect using a paint and a shadow shader. This is separate from drawRRect - * because it uses different underlying geometry and GeometryProcessor + * Draw a roundrect using a paint and a shadow shader. This is separate from drawRRect + * because it uses different underlying geometry and GeometryProcessor * - * @param paint describes how to color pixels. - * @param viewMatrix transformation matrix - * @param rrect the roundrect to draw - * @param blurRadius amount of shadow blur to apply (in device space) - * @param style style to apply to the rrect. Currently path effects are not allowed. + * @param paint describes how to color pixels. + * @param viewMatrix transformation matrix + * @param rrect the roundrect to draw + * @param blurRadius amount of shadow blur to apply (in device space) + * @param style style to apply to the rrect. Currently path effects are not allowed. */ void drawShadowRRect(const GrClip&, const GrPaint&, @@ -163,18 +156,17 @@ public: const GrStyle& style); /** - * Shortcut for filling a SkPath consisting of nested rrects using a paint. The result is - * undefined if outer does not contain inner. + * Shortcut for drawing an SkPath consisting of nested rrects using a paint. + * Does not support stroking. The result is undefined if outer does not contain + * inner. * - * @param paint describes how to color pixels. - * @param GrAA Controls whether rrects edges are antialiased - * @param viewMatrix transformation matrix - * @param outer the outer roundrect - * @param inner the inner roundrect + * @param paint describes how to color pixels. + * @param viewMatrix transformation matrix + * @param outer the outer roundrect + * @param inner the inner roundrect */ void drawDRRect(const GrClip&, const GrPaint&, - GrAA, const SkMatrix& viewMatrix, const SkRRect& outer, const SkRRect& inner); @@ -183,14 +175,12 @@ public: * Draws a path. * * @param paint describes how to color pixels. - * @param GrAA Controls whether the path is antialiased. * @param viewMatrix transformation matrix * @param path the path to draw * @param style style to apply to the path. */ void drawPath(const GrClip&, const GrPaint&, - GrAA, const SkMatrix& viewMatrix, const SkPath&, const GrStyle& style); @@ -224,8 +214,7 @@ public: int indexCount); /** - * Draws textured sprites from an atlas with a paint. This currently does not support AA for the - * sprite rectangle edges. + * Draws textured sprites from an atlas with a paint. * * @param paint describes how to color pixels. * @param viewMatrix transformation matrix @@ -248,13 +237,11 @@ public: * * @param paint describes how to color pixels * @param viewMatrix transformation matrix - * @param aa should the rects of the region be antialiased. * @param region the region to be drawn * @param style style to apply to the region */ void drawRegion(const GrClip&, const GrPaint& paint, - GrAA aa, const SkMatrix& viewMatrix, const SkRegion& region, const GrStyle& style); @@ -263,35 +250,31 @@ public: * Draws an oval. * * @param paint describes how to color pixels. - * @param GrAA Controls whether the oval is antialiased. * @param viewMatrix transformation matrix * @param oval the bounding rect of the oval. * @param style style to apply to the oval. Currently path effects are not allowed. */ void drawOval(const GrClip&, const GrPaint& paint, - GrAA, const SkMatrix& viewMatrix, const SkRect& oval, const GrStyle& style); - /** - * Draws a partial arc of an oval. - * - * @param paint describes how to color pixels. - * @param GrGrAA Controls whether the arc is antialiased. - * @param viewMatrix transformation matrix. - * @param oval the bounding rect of the oval. - * @param startAngle starting angle in degrees. - * @param sweepAngle angle to sweep in degrees. Must be in (-360, 360) - * @param useCenter true means that the implied path begins at the oval center, connects as - * a line to the point indicated by the start contains the arc indicated by - * the sweep angle. If false the line beginning at the center point is - * omitted. - * @param style style to apply to the oval. - */ + /** + * Draws a partial arc of an oval. + * + * @param paint describes how to color pixels. + * @param viewMatrix transformation matrix. + * @param oval the bounding rect of the oval. + * @param startAngle starting angle in degrees. + * @param sweepAngle angle to sweep in degrees. Must be in (-360, 360) + * @param useCenter true means that the implied path begins at the oval center, connects as a + * line to the point indicated by the start contains the arc indicated by + * the sweep angle. If false the line beginning at the center point is + * omitted. + * @param style style to apply to the oval. + */ void drawArc(const GrClip&, const GrPaint& paint, - GrAA, const SkMatrix& viewMatrix, const SkRect& oval, SkScalar startAngle, @@ -350,6 +333,10 @@ public: bool isUnifiedMultisampled() const { return fRenderTargetProxy->isUnifiedMultisampled(); } bool hasMixedSamples() const { return fRenderTargetProxy->isMixedSampled(); } + bool mustUseHWAA(const GrPaint& paint) const { + return paint.isAntiAlias() && fRenderTargetProxy->isUnifiedMultisampled(); + } + const GrCaps* caps() const { return fContext->caps(); } const GrSurfaceDesc& desc() const { return fRenderTargetProxy->desc(); } int width() const { return fRenderTargetProxy->width(); } @@ -405,19 +392,6 @@ protected: SkDEBUGCODE(void validate() const;) private: - inline GrAAType decideAAType(GrAA aa, bool allowMixedSamples = false) { - if (GrAA::kNo == aa) { - return GrAAType::kNone; - } - if (this->isUnifiedMultisampled()) { - return GrAAType::kMSAA; - } - if (allowMixedSamples && this->isStencilBufferMultisampled()) { - return GrAAType::kMixedSamples; - } - return GrAAType::kCoverage; - } - friend class GrAtlasTextBlob; // for access to addDrawOp friend class GrStencilAndCoverTextContext; // for access to addDrawOp @@ -443,14 +417,12 @@ private: bool drawFilledDRRect(const GrClip& clip, const GrPaint& paint, - GrAA, const SkMatrix& viewMatrix, const SkRRect& origOuter, const SkRRect& origInner); bool drawFilledRect(const GrClip& clip, const GrPaint& paint, - GrAA, const SkMatrix& viewMatrix, const SkRect& rect, const GrUserStencilSettings* ss); @@ -462,14 +434,13 @@ private: const SkRect* localRect, const SkMatrix* localMatrix, const GrUserStencilSettings* ss, - GrAAType hwOrNoneAAType); - - void internalDrawPath(const GrClip&, - const GrPaint&, - GrAA, - const SkMatrix&, - const SkPath&, - const GrStyle&); + bool useHWAA); + + void internalDrawPath(const GrClip& clip, + const GrPaint& paint, + const SkMatrix& viewMatrix, + const SkPath& path, + const GrStyle& style); // This entry point allows the GrTextContext-derived classes to add their ops to the GrOpList. void addDrawOp(const GrPipelineBuilder&, const GrClip&, GrDrawOp*); diff --git a/include/gpu/GrTypes.h b/include/gpu/GrTypes.h index 86e83f93e8..846537a546 100644 --- a/include/gpu/GrTypes.h +++ b/include/gpu/GrTypes.h @@ -149,18 +149,6 @@ typedef intptr_t GrBackendContext; /////////////////////////////////////////////////////////////////////////////// /** - * Used to control antialiasing in draw calls. - */ -enum class GrAA { - kYes, - kNo -}; - -static inline GrAA GrBoolToAA(bool aa) { return aa ? GrAA::kYes : GrAA::kNo; } - -/////////////////////////////////////////////////////////////////////////////// - -/** * Geometric primitives used for drawing. */ enum GrPrimitiveType { diff --git a/include/gpu/GrTypesPriv.h b/include/gpu/GrTypesPriv.h index 53e71e74ab..51dccc5f7d 100644 --- a/include/gpu/GrTypesPriv.h +++ b/include/gpu/GrTypesPriv.h @@ -11,21 +11,6 @@ #include "GrTypes.h" #include "SkRefCnt.h" -/** This enum indicates the type of antialiasing to be performed. */ -enum class GrAAType { - /** No antialiasing */ - kNone, - /** Use fragment shader code to compute a fractional pixel coverage. */ - kCoverage, - /** Use normal MSAA. */ - kMSAA, - /** - * Use "mixed samples" MSAA such that the stencil buffer is multisampled but the color buffer is - * not. - */ - kMixedSamples -}; - /** * Types of shader-language-specific boxed variables we can create. (Currently only GrGLShaderVars, * but should be applicable to other shader languages.) diff --git a/src/core/SkGpuBlurUtils.cpp b/src/core/SkGpuBlurUtils.cpp index e3463a4b78..2ae398df85 100644 --- a/src/core/SkGpuBlurUtils.cpp +++ b/src/core/SkGpuBlurUtils.cpp @@ -84,7 +84,7 @@ static void convolve_gaussian_1d(GrRenderTargetContext* renderTargetContext, paint.setPorterDuffXPFactory(SkBlendMode::kSrc); SkMatrix localMatrix = SkMatrix::MakeTrans(-SkIntToScalar(srcOffset.x()), -SkIntToScalar(srcOffset.y())); - renderTargetContext->fillRectWithLocalMatrix(clip, paint, GrAA::kNo, SkMatrix::I(), + renderTargetContext->fillRectWithLocalMatrix(clip, paint, SkMatrix::I(), SkRect::Make(dstRect), localMatrix); } @@ -112,7 +112,7 @@ static void convolve_gaussian_2d(GrRenderTargetContext* renderTargetContext, true, sigmaX, sigmaY)); paint.addColorFragmentProcessor(std::move(conv)); paint.setPorterDuffXPFactory(SkBlendMode::kSrc); - renderTargetContext->fillRectWithLocalMatrix(clip, paint, GrAA::kNo, SkMatrix::I(), + renderTargetContext->fillRectWithLocalMatrix(clip, paint, SkMatrix::I(), SkRect::Make(dstRect), localMatrix); } @@ -289,7 +289,7 @@ sk_sp<GrRenderTargetContext> GaussianBlur(GrContext* context, paint.setPorterDuffXPFactory(SkBlendMode::kSrc); shrink_irect_by_2(&dstRect, i < scaleFactorX, i < scaleFactorY); - dstRenderTargetContext->fillRectToRect(clip, paint, GrAA::kNo, SkMatrix::I(), + dstRenderTargetContext->fillRectToRect(clip, paint, SkMatrix::I(), SkRect::Make(dstRect), SkRect::Make(srcRect)); srcRenderTargetContext = dstRenderTargetContext; @@ -381,7 +381,7 @@ sk_sp<GrRenderTargetContext> GaussianBlur(GrContext* context, SkIRect dstRect(srcRect); scale_irect(&dstRect, scaleFactorX, scaleFactorY); - dstRenderTargetContext->fillRectToRect(clip, paint, GrAA::kNo, SkMatrix::I(), + dstRenderTargetContext->fillRectToRect(clip, paint, SkMatrix::I(), SkRect::Make(dstRect), SkRect::Make(srcRect)); srcRenderTargetContext = dstRenderTargetContext; diff --git a/src/core/SkImageFilter.cpp b/src/core/SkImageFilter.cpp index 2ec441f108..df46a13d3c 100644 --- a/src/core/SkImageFilter.cpp +++ b/src/core/SkImageFilter.cpp @@ -297,7 +297,7 @@ sk_sp<SkSpecialImage> SkImageFilter::DrawWithFP(GrContext* context, SkRect srcRect = SkRect::Make(bounds); SkRect dstRect = SkRect::MakeWH(srcRect.width(), srcRect.height()); GrFixedClip clip(dstIRect); - renderTargetContext->fillRectToRect(clip, paint, GrAA::kNo, SkMatrix::I(), dstRect, srcRect); + renderTargetContext->fillRectToRect(clip, paint, SkMatrix::I(), dstRect, srcRect); return SkSpecialImage::MakeDeferredFromGpu(context, dstIRect, kNeedNewImageUniqueID_SpecialImage, diff --git a/src/effects/SkAlphaThresholdFilter.cpp b/src/effects/SkAlphaThresholdFilter.cpp index 6cf1ce61e4..43751e1199 100644 --- a/src/effects/SkAlphaThresholdFilter.cpp +++ b/src/effects/SkAlphaThresholdFilter.cpp @@ -114,7 +114,7 @@ sk_sp<GrTextureProxy> SkAlphaThresholdFilterImpl::createMaskTexture(GrContext* c GrFixedClip clip(SkIRect::MakeWH(bounds.width(), bounds.height())); while (!iter.done()) { SkRect rect = SkRect::Make(iter.rect()); - rtContext->drawRect(clip, grPaint, GrAA::kNo, inMatrix, rect); + rtContext->drawRect(clip, grPaint, inMatrix, rect); iter.next(); } diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp index 0b1d1db6fb..e8867ead76 100644 --- a/src/effects/SkBlurMaskFilter.cpp +++ b/src/effects/SkBlurMaskFilter.cpp @@ -1060,8 +1060,7 @@ bool SkBlurMaskFilterImpl::directFilterMaskGPU(GrTextureProvider* texProvider, return false; } - renderTargetContext->fillRectWithLocalMatrix(clip, *grp, GrAA::kNo, SkMatrix::I(), rect, - inverse); + renderTargetContext->fillRectWithLocalMatrix(clip, *grp, SkMatrix::I(), rect, inverse); return true; } @@ -1104,7 +1103,8 @@ private: static sk_sp<GrTexture> find_or_create_rrect_blur_mask(GrContext* context, const SkRRect& rrectToDraw, const SkISize& size, - float xformedSigma) { + float xformedSigma, + bool doAA) { static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain(); GrUniqueKey key; GrUniqueKey::Builder builder(&key, kDomain, 9); @@ -1129,10 +1129,10 @@ static sk_sp<GrTexture> find_or_create_rrect_blur_mask(GrContext* context, } GrPaint grPaint; + grPaint.setAntiAlias(doAA); rtc->clear(nullptr, 0x0, true); - rtc->drawRRect(GrNoClip(), grPaint, GrAA::kYes, SkMatrix::I(), rrectToDraw, - GrStyle::SimpleFill()); + rtc->drawRRect(GrNoClip(), grPaint, SkMatrix::I(), rrectToDraw, GrStyle::SimpleFill()); sk_sp<GrTexture> srcTexture(rtc->asTexture()); if (!srcTexture) { @@ -1192,7 +1192,8 @@ sk_sp<GrFragmentProcessor> GrRRectBlurEffect::Make(GrContext* context, return nullptr; } - sk_sp<GrTexture> mask(find_or_create_rrect_blur_mask(context, rrectToDraw, size, xformedSigma)); + sk_sp<GrTexture> mask(find_or_create_rrect_blur_mask(context, rrectToDraw, size, + xformedSigma, true)); if (!mask) { return nullptr; } @@ -1379,11 +1380,12 @@ bool SkBlurMaskFilterImpl::directFilterRRectMaskGPU(GrContext* context, GrPaint newPaint(*grp); newPaint.addCoverageFragmentProcessor(std::move(fp)); + newPaint.setAntiAlias(false); SkRect srcProxyRect = srcRRect.rect(); srcProxyRect.outset(3.0f*fSigma, 3.0f*fSigma); - renderTargetContext->drawRect(clip, newPaint, GrAA::kNo, viewMatrix, srcProxyRect); + renderTargetContext->drawRect(clip, newPaint, viewMatrix, srcProxyRect); return true; } @@ -1395,6 +1397,7 @@ bool SkBlurMaskFilterImpl::directFilterRRectMaskGPU(GrContext* context, GrPaint newPaint(*grp); newPaint.addCoverageFragmentProcessor(std::move(fp)); + newPaint.setAntiAlias(false); if (!this->ignoreXform()) { SkRect srcProxyRect = srcRRect.rect(); @@ -1441,8 +1444,8 @@ bool SkBlurMaskFilterImpl::directFilterRRectMaskGPU(GrContext* context, proxyRect.outset(extra, extra); - renderTargetContext->fillRectWithLocalMatrix(clip, newPaint, GrAA::kNo, SkMatrix::I(), - proxyRect, inverse); + renderTargetContext->fillRectWithLocalMatrix(clip, newPaint, SkMatrix::I(), proxyRect, + inverse); } return true; @@ -1535,8 +1538,7 @@ bool SkBlurMaskFilterImpl::filterMaskGPU(GrTexture* src, paint.setCoverageSetOpXPFactory(SkRegion::kReplace_Op); } - renderTargetContext->drawRect(GrNoClip(), paint, GrAA::kNo, SkMatrix::I(), - SkRect::Make(clipRect)); + renderTargetContext->drawRect(GrNoClip(), paint, SkMatrix::I(), SkRect::Make(clipRect)); } *result = renderTargetContext->asTexture().release(); diff --git a/src/effects/SkDisplacementMapEffect.cpp b/src/effects/SkDisplacementMapEffect.cpp index 661dacd53b..2d79f9ac87 100644 --- a/src/effects/SkDisplacementMapEffect.cpp +++ b/src/effects/SkDisplacementMapEffect.cpp @@ -360,8 +360,7 @@ sk_sp<SkSpecialImage> SkDisplacementMapEffect::onFilterImage(SkSpecialImage* sou } paint.setGammaCorrect(renderTargetContext->isGammaCorrect()); - renderTargetContext->drawRect(GrNoClip(), paint, GrAA::kNo, matrix, - SkRect::Make(colorBounds)); + renderTargetContext->drawRect(GrNoClip(), paint, matrix, SkRect::Make(colorBounds)); offset->fX = bounds.left(); offset->fY = bounds.top(); diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp index 52c8947cc4..75947e8711 100644 --- a/src/effects/SkLightingImageFilter.cpp +++ b/src/effects/SkLightingImageFilter.cpp @@ -400,7 +400,7 @@ void SkLightingImageFilterInternal::drawRect(GrRenderTargetContext* renderTarget boundaryMode)); paint.addColorFragmentProcessor(std::move(fp)); paint.setPorterDuffXPFactory(SkBlendMode::kSrc); - renderTargetContext->fillRectToRect(clip, paint, GrAA::kNo, SkMatrix::I(), dstRect, srcRect); + renderTargetContext->fillRectToRect(clip, paint, SkMatrix::I(), dstRect, srcRect); } sk_sp<SkSpecialImage> SkLightingImageFilterInternal::filterImageGPU( diff --git a/src/effects/SkMorphologyImageFilter.cpp b/src/effects/SkMorphologyImageFilter.cpp index 130f099d85..2fa67a4aeb 100644 --- a/src/effects/SkMorphologyImageFilter.cpp +++ b/src/effects/SkMorphologyImageFilter.cpp @@ -407,8 +407,7 @@ static void apply_morphology_rect(GrTextureProvider* provider, paint.addColorFragmentProcessor(GrMorphologyEffect::Make(tex, direction, radius, morphType, bounds)); paint.setPorterDuffXPFactory(SkBlendMode::kSrc); - renderTargetContext->fillRectToRect(clip, paint, GrAA::kNo, - SkMatrix::I(), SkRect::Make(dstRect), + renderTargetContext->fillRectToRect(clip, paint, SkMatrix::I(), SkRect::Make(dstRect), SkRect::Make(srcRect)); } @@ -429,8 +428,8 @@ static void apply_morphology_rect_no_bounds(GrTextureProvider* provider, } paint.addColorFragmentProcessor(GrMorphologyEffect::Make(tex, direction, radius, morphType)); paint.setPorterDuffXPFactory(SkBlendMode::kSrc); - renderTargetContext->fillRectToRect(clip, paint, GrAA::kNo, SkMatrix::I(), - SkRect::Make(dstRect), SkRect::Make(srcRect)); + renderTargetContext->fillRectToRect(clip, paint, SkMatrix::I(), SkRect::Make(dstRect), + SkRect::Make(srcRect)); } static void apply_morphology_pass(GrTextureProvider* provider, diff --git a/src/effects/SkShadowMaskFilter.cpp b/src/effects/SkShadowMaskFilter.cpp index 5c54072f4e..958ab170a7 100755 --- a/src/effects/SkShadowMaskFilter.cpp +++ b/src/effects/SkShadowMaskFilter.cpp @@ -252,6 +252,7 @@ bool SkShadowMaskFilterImpl::directFilterRRectMaskGPU(GrContext*, const SkScalar devSpaceAmbientRadius = srcSpaceAmbientRadius * scaleFactor; GrPaint newPaint(*grp); + newPaint.setAntiAlias(true); GrColor4f color = newPaint.getColor4f(); color.fRGBA[3] *= fAmbientAlpha; newPaint.setColor4f(color); @@ -310,6 +311,7 @@ bool SkShadowMaskFilterImpl::directFilterRRectMaskGPU(GrContext*, (spotShadowRRect.width() + srcSpaceSpotRadius); GrPaint newPaint(*grp); + newPaint.setAntiAlias(true); GrColor4f color = newPaint.getColor4f(); color.fRGBA[3] *= fSpotAlpha; newPaint.setColor4f(color); diff --git a/src/effects/SkXfermodeImageFilter.cpp b/src/effects/SkXfermodeImageFilter.cpp index 3a1e6e28e3..82d5156a28 100644 --- a/src/effects/SkXfermodeImageFilter.cpp +++ b/src/effects/SkXfermodeImageFilter.cpp @@ -303,7 +303,7 @@ sk_sp<SkSpecialImage> SkXfermodeImageFilter_Base::filterImageGPU( SkMatrix matrix; matrix.setTranslate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top())); - renderTargetContext->drawRect(GrNoClip(), paint, GrAA::kNo, matrix, SkRect::Make(bounds)); + renderTargetContext->drawRect(GrNoClip(), paint, matrix, SkRect::Make(bounds)); return SkSpecialImage::MakeDeferredFromGpu(context, SkIRect::MakeWH(bounds.width(), bounds.height()), diff --git a/src/gpu/GrBlurUtils.cpp b/src/gpu/GrBlurUtils.cpp index 768860525f..4d89bef63c 100644 --- a/src/gpu/GrBlurUtils.cpp +++ b/src/gpu/GrBlurUtils.cpp @@ -45,8 +45,8 @@ static bool draw_mask(GrRenderTargetContext* renderTargetContext, if (!viewMatrix.invert(&inverse)) { return false; } - renderTargetContext->fillRectWithLocalMatrix(clip, *grp, GrAA::kNo, SkMatrix::I(), - SkRect::Make(maskRect), inverse); + renderTargetContext->fillRectWithLocalMatrix(clip, *grp, SkMatrix::I(), SkRect::Make(maskRect), + inverse); return true; } @@ -98,9 +98,9 @@ static sk_sp<GrTextureProxy> create_mask_GPU(GrContext* context, const SkIRect& maskRect, const SkPath& devPath, SkStrokeRec::InitStyle fillOrHairline, - GrAA aa, + bool doAA, int sampleCnt) { - if (GrAA::kNo == aa) { + if (!doAA) { // Don't need MSAA if mask isn't AA sampleCnt = 0; } @@ -115,6 +115,7 @@ static sk_sp<GrTextureProxy> create_mask_GPU(GrContext* context, rtContext->priv().absClear(nullptr, 0x0); GrPaint tempPaint; + tempPaint.setAntiAlias(doAA); tempPaint.setCoverageSetOpXPFactory(SkRegion::kReplace_Op); // setup new clip @@ -125,7 +126,7 @@ static sk_sp<GrTextureProxy> create_mask_GPU(GrContext* context, // the origin using tempPaint. SkMatrix translate; translate.setTranslate(-SkIntToScalar(maskRect.fLeft), -SkIntToScalar(maskRect.fTop)); - rtContext->drawPath(clip, tempPaint, aa, translate, devPath, GrStyle(fillOrHairline)); + rtContext->drawPath(clip, tempPaint, translate, devPath, GrStyle(fillOrHairline)); return sk_ref_sp(rtContext->asDeferredTexture()); } @@ -133,7 +134,6 @@ static void draw_path_with_mask_filter(GrContext* context, GrRenderTargetContext* renderTargetContext, const GrClip& clip, GrPaint* paint, - GrAA aa, const SkMatrix& viewMatrix, const SkMaskFilter* maskFilter, const GrStyle& style, @@ -211,7 +211,7 @@ static void draw_path_with_mask_filter(GrContext* context, finalIRect, *path, fillOrHairline, - aa, + paint->isAntiAlias(), renderTargetContext->numColorSamples())); if (maskProxy) { GrTexture* filtered; @@ -242,12 +242,11 @@ void GrBlurUtils::drawPathWithMaskFilter(GrContext* context, const GrClip& clip, const SkPath& path, GrPaint* paint, - GrAA aa, const SkMatrix& viewMatrix, const SkMaskFilter* mf, const GrStyle& style, bool pathIsMutable) { - draw_path_with_mask_filter(context, renderTargetContext, clip, paint, aa, viewMatrix, mf, + draw_path_with_mask_filter(context, renderTargetContext, clip, paint, viewMatrix, mf, style, &path, pathIsMutable); } @@ -291,14 +290,14 @@ void GrBlurUtils::drawPathWithMaskFilter(GrContext* context, if (!SkPaintToGrPaint(context, renderTargetContext, paint, viewMatrix, &grPaint)) { return; } - GrAA aa = GrBoolToAA(paint.isAntiAlias()); + SkMaskFilter* mf = paint.getMaskFilter(); if (mf && !mf->asFragmentProcessor(nullptr, nullptr, viewMatrix)) { // The MaskFilter wasn't already handled in SkPaintToGrPaint - draw_path_with_mask_filter(context, renderTargetContext, clip, &grPaint, aa, viewMatrix, + draw_path_with_mask_filter(context, renderTargetContext, clip, &grPaint, viewMatrix, mf, style, path, pathIsMutable); } else { - renderTargetContext->drawPath(clip, grPaint, aa, viewMatrix, *path, style); + renderTargetContext->drawPath(clip, grPaint, viewMatrix, *path, style); } } diff --git a/src/gpu/GrBlurUtils.h b/src/gpu/GrBlurUtils.h index be0d2fb33c..090448fb6e 100644 --- a/src/gpu/GrBlurUtils.h +++ b/src/gpu/GrBlurUtils.h @@ -8,13 +8,11 @@ #ifndef GrBlurUtils_DEFINED #define GrBlurUtils_DEFINED -#include "GrTypes.h" - class GrClip; class GrContext; +class GrRenderTargetContext; class GrPaint; class GrRenderTarget; -class GrRenderTargetContext; class GrStyle; struct SkIRect; class SkMaskFilter; @@ -50,7 +48,6 @@ namespace GrBlurUtils { const GrClip&, const SkPath& path, GrPaint*, - GrAA, const SkMatrix& viewMatrix, const SkMaskFilter*, const GrStyle&, diff --git a/src/gpu/GrClipStackClip.cpp b/src/gpu/GrClipStackClip.cpp index 1172bc6a7b..e2ce0464f0 100644 --- a/src/gpu/GrClipStackClip.cpp +++ b/src/gpu/GrClipStackClip.cpp @@ -42,7 +42,7 @@ bool GrClipStackClip::quickContains(const SkRRect& rrect) const { SkIntToScalar(fOrigin.fY))); } -bool GrClipStackClip::isRRect(const SkRect& origRTBounds, SkRRect* rr, GrAA* aa) const { +bool GrClipStackClip::isRRect(const SkRect& origRTBounds, SkRRect* rr, bool* aa) const { if (!fStack) { return false; } @@ -54,9 +54,7 @@ bool GrClipStackClip::isRRect(const SkRect& origRTBounds, SkRRect* rr, GrAA* aa) tempRTBounds.offset(SkIntToScalar(fOrigin.fX), SkIntToScalar(fOrigin.fY)); rtBounds = &tempRTBounds; } - bool isAA; - if (fStack->isRRect(*rtBounds, rr, &isAA)) { - *aa = GrBoolToAA(isAA); + if (fStack->isRRect(*rtBounds, rr, aa)) { if (origin) { rr->offset(-SkIntToScalar(fOrigin.fX), -SkIntToScalar(fOrigin.fY)); } @@ -134,16 +132,9 @@ bool GrClipStackClip::PathNeedsSWRenderer(GrContext* context, canDrawArgs.fShaderCaps = context->caps()->shaderCaps(); canDrawArgs.fViewMatrix = &viewMatrix; canDrawArgs.fShape = &shape; - if (!element->isAA()) { - canDrawArgs.fAAType = GrAAType::kNone; - } else if (renderTargetContext->isUnifiedMultisampled()) { - canDrawArgs.fAAType = GrAAType::kMSAA; - } else if (renderTargetContext->isStencilBufferMultisampled()){ - canDrawArgs.fAAType = GrAAType::kMixedSamples; - } else { - canDrawArgs.fAAType = GrAAType::kCoverage; - } + canDrawArgs.fAntiAlias = element->isAA(); canDrawArgs.fHasUserStencilSettings = hasUserStencilSettings; + canDrawArgs.fIsStencilBufferMSAA = renderTargetContext->isStencilBufferMultisampled(); // the 'false' parameter disallows use of the SW path renderer GrPathRenderer* pr = @@ -459,7 +450,6 @@ sk_sp<GrTexture> GrClipStackClip::CreateSoftwareClipMask(GrTextureProvider* texP for (ElementList::Iter iter(reducedClip.elements()); iter.get(); iter.next()) { const Element* element = iter.get(); SkClipOp op = element->getOp(); - GrAA aa = GrBoolToAA(element->isAA()); if (kIntersect_SkClipOp == op || kReverseDifference_SkClipOp == op) { // Intersect and reverse difference require modifying pixels outside of the geometry @@ -469,25 +459,25 @@ sk_sp<GrTexture> GrClipStackClip::CreateSoftwareClipMask(GrTextureProvider* texP if (kReverseDifference_SkClipOp == op) { SkRect temp = SkRect::Make(reducedClip.ibounds()); // invert the entire scene - helper.drawRect(temp, SkRegion::kXOR_Op, GrAA::kNo, 0xFF); + helper.drawRect(temp, SkRegion::kXOR_Op, false, 0xFF); } SkPath clipPath; element->asPath(&clipPath); clipPath.toggleInverseFillType(); GrShape shape(clipPath, GrStyle::SimpleFill()); - helper.drawShape(shape, SkRegion::kReplace_Op, aa, 0x00); + helper.drawShape(shape, SkRegion::kReplace_Op, element->isAA(), 0x00); continue; } // The other ops (union, xor, diff) only affect pixels inside // the geometry so they can just be drawn normally if (Element::kRect_Type == element->getType()) { - helper.drawRect(element->getRect(), (SkRegion::Op)op, aa, 0xFF); + helper.drawRect(element->getRect(), (SkRegion::Op)op, element->isAA(), 0xFF); } else { SkPath path; element->asPath(&path); GrShape shape(path, GrStyle::SimpleFill()); - helper.drawShape(shape, (SkRegion::Op)op, aa, 0xFF); + helper.drawShape(shape, (SkRegion::Op)op, element->isAA(), 0xFF); } } diff --git a/src/gpu/GrClipStackClip.h b/src/gpu/GrClipStackClip.h index 42bd373b09..afda3eb43c 100644 --- a/src/gpu/GrClipStackClip.h +++ b/src/gpu/GrClipStackClip.h @@ -38,7 +38,7 @@ public: bool apply(GrContext*, GrRenderTargetContext*, bool useHWAA, bool hasUserStencilSettings, GrAppliedClip* out) const final; - bool isRRect(const SkRect& rtBounds, SkRRect* rr, GrAA* aa) const override; + bool isRRect(const SkRect& rtBounds, SkRRect* rr, bool* aa) const override; private: static bool PathNeedsSWRenderer(GrContext* context, diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp index ff5b0266e6..34b9abff68 100644 --- a/src/gpu/GrContext.cpp +++ b/src/gpu/GrContext.cpp @@ -366,7 +366,7 @@ bool GrContext::writeSurfacePixels(GrSurface* surface, paint.setPorterDuffXPFactory(SkBlendMode::kSrc); paint.setAllowSRGBInputs(true); SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height)); - renderTargetContext->drawRect(GrNoClip(), paint, GrAA::kNo, matrix, rect, nullptr); + renderTargetContext->drawRect(GrNoClip(), paint, matrix, rect, nullptr); if (kFlushWrites_PixelOp & pixelOpsFlags) { this->flushSurfaceWrites(surface); @@ -486,7 +486,7 @@ bool GrContext::readSurfacePixels(GrSurface* src, paint.setPorterDuffXPFactory(SkBlendMode::kSrc); paint.setAllowSRGBInputs(true); SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height)); - tempRTC->drawRect(GrNoClip(), paint, GrAA::kNo, SkMatrix::I(), rect, nullptr); + tempRTC->drawRect(GrNoClip(), paint, SkMatrix::I(), rect, nullptr); surfaceToRead.reset(tempRTC->asTexture().release()); left = 0; top = 0; diff --git a/src/gpu/GrDrawingManager.cpp b/src/gpu/GrDrawingManager.cpp index 9cbdbbe93a..c82f49ab7f 100644 --- a/src/gpu/GrDrawingManager.cpp +++ b/src/gpu/GrDrawingManager.cpp @@ -222,9 +222,7 @@ GrPathRenderer* GrDrawingManager::getPathRenderer(const GrPathRenderer::CanDrawP new GrSoftwarePathRenderer(fContext->textureProvider(), fOptionsForPathRendererChain.fAllowPathMaskCaching); } - if (fSoftwarePathRenderer->canDrawPath(args)) { - pr = fSoftwarePathRenderer; - } + pr = fSoftwarePathRenderer; } return pr; diff --git a/src/gpu/GrFixedClip.cpp b/src/gpu/GrFixedClip.cpp index d584ee119e..79e26624d2 100644 --- a/src/gpu/GrFixedClip.cpp +++ b/src/gpu/GrFixedClip.cpp @@ -29,7 +29,7 @@ void GrFixedClip::getConservativeBounds(int w, int h, SkIRect* devResult, bool* } } -bool GrFixedClip::isRRect(const SkRect& rtBounds, SkRRect* rr, GrAA* aa) const { +bool GrFixedClip::isRRect(const SkRect& rtBounds, SkRRect* rr, bool* aa) const { if (fWindowRectsState.enabled()) { return false; } @@ -39,7 +39,7 @@ bool GrFixedClip::isRRect(const SkRect& rtBounds, SkRRect* rr, GrAA* aa) const { return false; } rr->setRect(rect); - *aa = GrAA::kNo; + *aa = false; return true; } return false; diff --git a/src/gpu/GrFixedClip.h b/src/gpu/GrFixedClip.h index 7f18c2667f..6c350d5cba 100644 --- a/src/gpu/GrFixedClip.h +++ b/src/gpu/GrFixedClip.h @@ -42,7 +42,7 @@ public: bool quickContains(const SkRect&) const override; void getConservativeBounds(int w, int h, SkIRect* devResult, bool* iior) const override; - bool isRRect(const SkRect& rtBounds, SkRRect* rr, GrAA*) const override; + bool isRRect(const SkRect& rtBounds, SkRRect* rr, bool* aa) const override; bool apply(GrContext*, GrRenderTargetContext*, bool, bool, GrAppliedClip* out) const override; static const GrFixedClip& Disabled(); diff --git a/src/gpu/GrPaint.cpp b/src/gpu/GrPaint.cpp index 0954505b80..d5f8d3d0c1 100644 --- a/src/gpu/GrPaint.cpp +++ b/src/gpu/GrPaint.cpp @@ -13,7 +13,8 @@ #include "effects/GrSimpleTextureEffect.h" GrPaint::GrPaint() - : fDisableOutputConversionToSRGB(false) + : fAntiAlias(false) + , fDisableOutputConversionToSRGB(false) , fAllowSRGBInputs(false) , fUsesDistanceVectorField(false) , fColor(GrColor4f::OpaqueWhite()) {} diff --git a/src/gpu/GrPathRenderer.h b/src/gpu/GrPathRenderer.h index c002c12889..2b5ccdc883 100644 --- a/src/gpu/GrPathRenderer.h +++ b/src/gpu/GrPathRenderer.h @@ -78,16 +78,17 @@ public: * fPipelineBuilder The pipelineBuilder * fViewMatrix The viewMatrix * fShape The shape to draw - * fAntiAlias The type of anti aliasing required. + * fAntiAlias True if anti-aliasing is required. */ struct CanDrawPathArgs { const GrShaderCaps* fShaderCaps; const SkMatrix* fViewMatrix; const GrShape* fShape; - GrAAType fAAType; + bool fAntiAlias; // These next two are only used by GrStencilAndCoverPathRenderer bool fHasUserStencilSettings; + bool fIsStencilBufferMSAA; #ifdef SK_DEBUG void validate() const { @@ -120,7 +121,7 @@ public: * fColor Color to render with * fViewMatrix The viewMatrix * fShape The shape to draw - * fAAtype true if anti-aliasing is required. + * fAntiAlias true if anti-aliasing is required. * fGammaCorrect true if gamma-correct rendering is to be used. */ struct DrawPathArgs { @@ -132,7 +133,7 @@ public: const GrClip* fClip; const SkMatrix* fViewMatrix; const GrShape* fShape; - GrAAType fAAType; + bool fAntiAlias; bool fGammaCorrect; #ifdef SK_DEBUG void validate() const { @@ -158,13 +159,10 @@ public: canArgs.fShaderCaps = args.fResourceProvider->caps()->shaderCaps(); canArgs.fViewMatrix = args.fViewMatrix; canArgs.fShape = args.fShape; - canArgs.fAAType = args.fAAType; + canArgs.fAntiAlias = args.fAntiAlias; canArgs.fHasUserStencilSettings = !args.fUserStencilSettings->isUnused(); - SkASSERT(!(canArgs.fAAType == GrAAType::kMSAA && - !args.fRenderTargetContext->isUnifiedMultisampled())); - SkASSERT(!(canArgs.fAAType == GrAAType::kMixedSamples && - !args.fRenderTargetContext->isStencilBufferMultisampled())); + canArgs.fIsStencilBufferMSAA = args.fRenderTargetContext->isStencilBufferMultisampled(); SkASSERT(this->canDrawPath(canArgs)); if (!args.fUserStencilSettings->isUnused()) { SkPath path; @@ -182,14 +180,14 @@ public: * fRenderTargetContext The target of the draws * fViewMatrix Matrix applied to the path. * fPath The path to draw. - * fAAType The type of AA, cannot be kCoverage. + * fIsAA Is the path to be drawn AA (only set when MSAA is available) */ struct StencilPathArgs { GrResourceProvider* fResourceProvider; GrRenderTargetContext* fRenderTargetContext; const GrClip* fClip; const SkMatrix* fViewMatrix; - GrAAType fAAType; + bool fIsAA; const GrShape* fShape; #ifdef SK_DEBUG @@ -199,7 +197,6 @@ public: SkASSERT(fViewMatrix); SkASSERT(fShape); SkASSERT(fShape->style().isSimpleFill()); - SkASSERT(GrAAType::kCoverage != fAAType); SkPath path; fShape->asPath(&path); SkASSERT(!path.isInverseFillType()); @@ -286,7 +283,7 @@ private: drawArgs.fRenderTargetContext = args.fRenderTargetContext; drawArgs.fViewMatrix = args.fViewMatrix; drawArgs.fShape = args.fShape; - drawArgs.fAAType = args.fAAType; + drawArgs.fAntiAlias = false; // In this case the MSAA handles the AA so we want to draw BW drawArgs.fGammaCorrect = false; this->drawPath(drawArgs); } diff --git a/src/gpu/GrPipelineBuilder.cpp b/src/gpu/GrPipelineBuilder.cpp index f2dd1acc4e..fac5752f70 100644 --- a/src/gpu/GrPipelineBuilder.cpp +++ b/src/gpu/GrPipelineBuilder.cpp @@ -15,10 +15,15 @@ #include "batches/GrOp.h" #include "effects/GrPorterDuffXferProcessor.h" -GrPipelineBuilder::GrPipelineBuilder(const GrPaint& paint, GrAAType aaType) - : fFlags(0x0) - , fUserStencilSettings(&GrUserStencilSettings::kUnused) - , fDrawFace(GrDrawFace::kBoth) { +GrPipelineBuilder::GrPipelineBuilder() + : fFlags(0x0) + , fUserStencilSettings(&GrUserStencilSettings::kUnused) + , fDrawFace(GrDrawFace::kBoth) { + SkDEBUGCODE(fBlockEffectRemovalCnt = 0;) +} + +GrPipelineBuilder::GrPipelineBuilder(const GrPaint& paint, bool useHWAA) + : GrPipelineBuilder() { SkDEBUGCODE(fBlockEffectRemovalCnt = 0;) for (int i = 0; i < paint.numColorFragmentProcessors(); ++i) { @@ -31,8 +36,7 @@ GrPipelineBuilder::GrPipelineBuilder(const GrPaint& paint, GrAAType aaType) fXPFactory.reset(SkSafeRef(paint.getXPFactory())); - this->setState(GrPipelineBuilder::kHWAntialias_Flag, GrAAType::kMSAA == aaType || - GrAAType::kMixedSamples == aaType); + this->setState(GrPipelineBuilder::kHWAntialias_Flag, useHWAA); this->setState(GrPipelineBuilder::kDisableOutputConversionToSRGB_Flag, paint.getDisableOutputConversionToSRGB()); this->setState(GrPipelineBuilder::kAllowSRGBInputs_Flag, diff --git a/src/gpu/GrPipelineBuilder.h b/src/gpu/GrPipelineBuilder.h index 69aa45491a..fcff2adafd 100644 --- a/src/gpu/GrPipelineBuilder.h +++ b/src/gpu/GrPipelineBuilder.h @@ -29,14 +29,15 @@ class GrTexture; class GrPipelineBuilder : public SkNoncopyable { public: -// GrPipelineBuilder(); + GrPipelineBuilder(); + /** * Initializes the GrPipelineBuilder based on a GrPaint and MSAA availability. Note * that GrPipelineBuilder encompasses more than GrPaint. Aspects of GrPipelineBuilder that have * no GrPaint equivalents are set to default values with the exception of vertex attribute state * which is unmodified by this function and clipping which will be enabled. */ - GrPipelineBuilder(const GrPaint& paint, GrAAType aaType); + GrPipelineBuilder(const GrPaint&, bool useHWAA = false); virtual ~GrPipelineBuilder(); diff --git a/src/gpu/GrReducedClip.cpp b/src/gpu/GrReducedClip.cpp index 8b9090f427..c5d764d3b7 100644 --- a/src/gpu/GrReducedClip.cpp +++ b/src/gpu/GrReducedClip.cpp @@ -529,7 +529,8 @@ static bool stencil_element(GrRenderTargetContext* rtc, const GrUserStencilSettings* ss, const SkMatrix& viewMatrix, const SkClipStack::Element* element) { - GrAA aa = GrBoolToAA(element->isAA()); + + // TODO: Draw rrects directly here. switch (element->getType()) { case Element::kEmpty_Type: SkDEBUGFAIL("Should never get here with an empty element."); @@ -537,7 +538,9 @@ static bool stencil_element(GrRenderTargetContext* rtc, case Element::kRect_Type: return rtc->priv().drawAndStencilRect(clip, ss, (SkRegion::Op)element->getOp(), - element->isInverseFilled(), aa, viewMatrix, + element->isInverseFilled(), + element->isAA(), + viewMatrix, element->getRect()); break; default: { @@ -547,8 +550,11 @@ static bool stencil_element(GrRenderTargetContext* rtc, path.toggleInverseFillType(); } - return rtc->priv().drawAndStencilPath(clip, ss, (SkRegion::Op)element->getOp(), - element->isInverseFilled(), aa, viewMatrix, path); + return rtc->priv().drawAndStencilPath(clip, ss, + (SkRegion::Op)element->getOp(), + element->isInverseFilled(), + element->isAA(), viewMatrix, + path); break; } } @@ -559,7 +565,6 @@ static bool stencil_element(GrRenderTargetContext* rtc, static void draw_element(GrRenderTargetContext* rtc, const GrClip& clip, // TODO: can this just always be WideOpen? const GrPaint &paint, - GrAA aa, const SkMatrix& viewMatrix, const SkClipStack::Element* element) { @@ -569,7 +574,7 @@ static void draw_element(GrRenderTargetContext* rtc, SkDEBUGFAIL("Should never get here with an empty element."); break; case Element::kRect_Type: - rtc->drawRect(clip, paint, aa, viewMatrix, element->getRect()); + rtc->drawRect(clip, paint, viewMatrix, element->getRect()); break; default: { SkPath path; @@ -578,7 +583,7 @@ static void draw_element(GrRenderTargetContext* rtc, path.toggleInverseFillType(); } - rtc->drawPath(clip, paint, aa, viewMatrix, path, GrStyle::SimpleFill()); + rtc->drawPath(clip, paint, viewMatrix, path, GrStyle::SimpleFill()); break; } } @@ -607,7 +612,6 @@ bool GrReducedClip::drawAlphaClipMask(GrRenderTargetContext* rtc) const { for (ElementList::Iter iter(fElements); iter.get(); iter.next()) { const Element* element = iter.get(); SkRegion::Op op = (SkRegion::Op)element->getOp(); - GrAA aa = GrBoolToAA(element->isAA()); bool invert = element->isInverseFilled(); if (invert || SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op) { // draw directly into the result with the stencil set to make the pixels affected @@ -635,16 +639,17 @@ bool GrReducedClip::drawAlphaClipMask(GrRenderTargetContext* rtc) const { GrUserStencilOp::kZero, 0xffff>() ); - if (!rtc->priv().drawAndStencilRect(clip, &kDrawOutsideElement, op, !invert, GrAA::kNo, + if (!rtc->priv().drawAndStencilRect(clip, &kDrawOutsideElement, op, !invert, false, translate, SkRect::Make(fIBounds))) { return false; } } else { // all the remaining ops can just be directly draw into the accumulation buffer GrPaint paint; + paint.setAntiAlias(element->isAA()); paint.setCoverageSetOpXPFactory(op, false); - draw_element(rtc, clip, paint, aa, translate, element); + draw_element(rtc, clip, paint, translate, element); } } @@ -671,7 +676,7 @@ private: void getConservativeBounds(int width, int height, SkIRect* bounds, bool* iior) const override { fFixedClip.getConservativeBounds(width, height, bounds, iior); } - bool isRRect(const SkRect& rtBounds, SkRRect* rr, GrAA*) const override { + bool isRRect(const SkRect& rtBounds, SkRRect* rr, bool* aa) const override { return false; } bool apply(GrContext* context, GrRenderTargetContext* renderTargetContext, bool useHWAA, @@ -706,13 +711,11 @@ bool GrReducedClip::drawStencilClipMask(GrContext* context, SkMatrix viewMatrix; viewMatrix.setTranslate(SkIntToScalar(-clipOrigin.x()), SkIntToScalar(-clipOrigin.y())); - // walk through each clip element and perform its set op with the existing clip. + // walk through each clip element and perform its set op + // with the existing clip. for (ElementList::Iter iter(fElements); iter.get(); iter.next()) { const Element* element = iter.get(); - GrAAType aaType = GrAAType::kNone; - if (element->isAA() && renderTargetContext->isStencilBufferMultisampled()) { - aaType = GrAAType::kMSAA; - } + bool useHWAA = element->isAA() && renderTargetContext->isStencilBufferMultisampled(); bool fillInverted = false; @@ -739,8 +742,9 @@ bool GrReducedClip::drawStencilClipMask(GrContext* context, canDrawArgs.fShaderCaps = context->caps()->shaderCaps(); canDrawArgs.fViewMatrix = &viewMatrix; canDrawArgs.fShape = &shape; - canDrawArgs.fAAType = aaType; + canDrawArgs.fAntiAlias = false; canDrawArgs.fHasUserStencilSettings = false; + canDrawArgs.fIsStencilBufferMSAA = renderTargetContext->isStencilBufferMultisampled(); GrDrawingManager* dm = context->contextPriv().drawingManager(); pr = dm->getPathRenderer(canDrawArgs, false, @@ -774,13 +778,14 @@ bool GrReducedClip::drawStencilClipMask(GrContext* context, ); if (Element::kRect_Type == element->getType()) { renderTargetContext->priv().stencilRect(stencilClip.fixedClip(), &kDrawToStencil, - aaType, viewMatrix, element->getRect()); + useHWAA, viewMatrix, element->getRect()); } else { if (!clipPath.isEmpty()) { GrShape shape(clipPath, GrStyle::SimpleFill()); if (canRenderDirectToStencil) { GrPaint paint; paint.setXPFactory(GrDisableColorXPFactory::Make()); + paint.setAntiAlias(element->isAA()); GrPathRenderer::DrawPathArgs args; args.fResourceProvider = context->resourceProvider(); @@ -790,7 +795,7 @@ bool GrReducedClip::drawStencilClipMask(GrContext* context, args.fClip = &stencilClip.fixedClip(); args.fViewMatrix = &viewMatrix; args.fShape = &shape; - args.fAAType = aaType; + args.fAntiAlias = false; args.fGammaCorrect = false; pr->drawPath(args); } else { @@ -799,7 +804,7 @@ bool GrReducedClip::drawStencilClipMask(GrContext* context, args.fRenderTargetContext = renderTargetContext; args.fClip = &stencilClip.fixedClip(); args.fViewMatrix = &viewMatrix; - args.fAAType = aaType; + args.fIsAA = element->isAA(); args.fShape = &shape; pr->stencilPath(args); } @@ -812,12 +817,13 @@ bool GrReducedClip::drawStencilClipMask(GrContext* context, for (GrUserStencilSettings const* const* pass = stencilPasses; *pass; ++pass) { if (drawDirectToClip) { if (Element::kRect_Type == element->getType()) { - renderTargetContext->priv().stencilRect(stencilClip, *pass, aaType, viewMatrix, + renderTargetContext->priv().stencilRect(stencilClip, *pass, useHWAA, viewMatrix, element->getRect()); } else { GrShape shape(clipPath, GrStyle::SimpleFill()); GrPaint paint; paint.setXPFactory(GrDisableColorXPFactory::Make()); + paint.setAntiAlias(element->isAA()); GrPathRenderer::DrawPathArgs args; args.fResourceProvider = context->resourceProvider(); args.fPaint = &paint; @@ -826,14 +832,14 @@ bool GrReducedClip::drawStencilClipMask(GrContext* context, args.fClip = &stencilClip; args.fViewMatrix = &viewMatrix; args.fShape = &shape; - args.fAAType = aaType; + args.fAntiAlias = false; args.fGammaCorrect = false; pr->drawPath(args); } } else { // The view matrix is setup to do clip space -> stencil space translation, so // draw rect in clip space. - renderTargetContext->priv().stencilRect(stencilClip, *pass, aaType, viewMatrix, + renderTargetContext->priv().stencilRect(stencilClip, *pass, false, viewMatrix, SkRect::Make(fIBounds)); } } diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp index 6ef34d22bb..ebdf810c8f 100644 --- a/src/gpu/GrRenderTargetContext.cpp +++ b/src/gpu/GrRenderTargetContext.cpp @@ -324,7 +324,7 @@ void GrRenderTargetContext::internalClear(const GrFixedClip& clip, paint.setColor4f(GrColor4f::FromGrColor(color)); paint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc)); - this->drawRect(clip, paint, GrAA::kNo, SkMatrix::I(), SkRect::Make(clearRect)); + this->drawRect(clip, paint, SkMatrix::I(), SkRect::Make(clearRect)); } else if (isFull) { if (this->accessRenderTarget()) { this->getOpList()->fullClear(this->accessRenderTarget(), color); @@ -342,7 +342,7 @@ void GrRenderTargetContext::internalClear(const GrFixedClip& clip, } void GrRenderTargetContext::drawPaint(const GrClip& clip, - const GrPaint& paint, + const GrPaint& origPaint, const SkMatrix& viewMatrix) { ASSERT_SINGLE_OWNER RETURN_IF_ABANDONED @@ -353,19 +353,26 @@ void GrRenderTargetContext::drawPaint(const GrClip& clip, // don't overflow fixed-point implementations SkRect r = fRenderTargetProxy->getBoundsRect(); + SkTCopyOnFirstWrite<GrPaint> paint(origPaint); SkRRect rrect; - GrAA aa; + bool aaRRect; // Check if we can replace a clipRRect()/drawPaint() with a drawRRect(). We only do the // transformation for non-rect rrects. Rects caused a performance regression on an Android // test that needs investigation. We also skip cases where there are fragment processors // because they may depend on having correct local coords and this path draws in device space // without a local matrix. - if (!paint.numTotalFragmentProcessors() && clip.isRRect(r, &rrect, &aa) && !rrect.isRect()) { - this->drawRRect(GrNoClip(), paint, aa, SkMatrix::I(), rrect, GrStyle::SimpleFill()); + if (!paint->numTotalFragmentProcessors() && + clip.isRRect(r, &rrect, &aaRRect) && !rrect.isRect()) { + paint.writable()->setAntiAlias(aaRRect); + this->drawRRect(GrNoClip(), *paint, SkMatrix::I(), rrect, GrStyle::SimpleFill()); return; } + // by definition this fills the entire clip, no need for AA + if (paint->isAntiAlias()) { + paint.writable()->setAntiAlias(false); + } bool isPerspective = viewMatrix.hasPerspective(); @@ -377,7 +384,7 @@ void GrRenderTargetContext::drawPaint(const GrClip& clip, SkDebugf("Could not invert matrix\n"); return; } - this->drawRect(clip, paint, GrAA::kNo, viewMatrix, r); + this->drawRect(clip, *paint, viewMatrix, r); } else { SkMatrix localMatrix; if (!viewMatrix.invert(&localMatrix)) { @@ -387,8 +394,8 @@ void GrRenderTargetContext::drawPaint(const GrClip& clip, AutoCheckFlush acf(fDrawingManager); - this->drawNonAAFilledRect(clip, paint, SkMatrix::I(), r, nullptr, &localMatrix, - nullptr, GrAAType::kNone); + this->drawNonAAFilledRect(clip, *paint, SkMatrix::I(), r, nullptr, &localMatrix, nullptr, + false /* useHWAA */); } } @@ -401,6 +408,21 @@ static bool view_matrix_ok_for_aa_fill_rect(const SkMatrix& viewMatrix) { return viewMatrix.preservesRightAngles(); } +static bool should_apply_coverage_aa(const GrPaint& paint, GrRenderTargetProxy* rtp, + bool* useHWAA = nullptr) { + if (!paint.isAntiAlias()) { + if (useHWAA) { + *useHWAA = false; + } + return false; + } else { + if (useHWAA) { + *useHWAA = rtp->isUnifiedMultisampled(); + } + return !rtp->isUnifiedMultisampled(); + } +} + // Attempts to crop a rect and optional local rect to the clip boundaries. // Returns false if the draw can be skipped entirely. static bool crop_filled_rect(int width, int height, const GrClip& clip, @@ -448,7 +470,6 @@ static bool crop_filled_rect(int width, int height, const GrClip& clip, bool GrRenderTargetContext::drawFilledRect(const GrClip& clip, const GrPaint& paint, - GrAA aa, const SkMatrix& viewMatrix, const SkRect& rect, const GrUserStencilSettings* ss) { @@ -458,14 +479,14 @@ bool GrRenderTargetContext::drawFilledRect(const GrClip& clip, } sk_sp<GrDrawOp> op; - GrAAType aaType; + bool useHWAA; if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport()) { InstancedRendering* ir = this->getOpList()->instancedRendering(); - op.reset(ir->recordRect(croppedRect, viewMatrix, paint.getColor(), aa, - fInstancedPipelineInfo, &aaType)); + op.reset(ir->recordRect(croppedRect, viewMatrix, paint.getColor(), paint.isAntiAlias(), + fInstancedPipelineInfo, &useHWAA)); if (op) { - GrPipelineBuilder pipelineBuilder(paint, aaType); + GrPipelineBuilder pipelineBuilder(paint, useHWAA); if (ss) { pipelineBuilder.setUserStencil(ss); } @@ -473,8 +494,8 @@ bool GrRenderTargetContext::drawFilledRect(const GrClip& clip, return true; } } - aaType = this->decideAAType(aa); - if (GrAAType::kCoverage == aaType) { + + if (should_apply_coverage_aa(paint, fRenderTargetProxy.get(), &useHWAA)) { // The fill path can handle rotation but not skew. if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) { SkRect devBoundRect; @@ -483,7 +504,7 @@ bool GrRenderTargetContext::drawFilledRect(const GrClip& clip, op.reset(GrRectBatchFactory::CreateAAFill(paint, viewMatrix, rect, croppedRect, devBoundRect)); if (op) { - GrPipelineBuilder pipelineBuilder(paint, aaType); + GrPipelineBuilder pipelineBuilder(paint, useHWAA); if (ss) { pipelineBuilder.setUserStencil(ss); } @@ -493,7 +514,7 @@ bool GrRenderTargetContext::drawFilledRect(const GrClip& clip, } } else { this->drawNonAAFilledRect(clip, paint, viewMatrix, croppedRect, nullptr, nullptr, ss, - aaType); + useHWAA); return true; } @@ -502,7 +523,6 @@ bool GrRenderTargetContext::drawFilledRect(const GrClip& clip, void GrRenderTargetContext::drawRect(const GrClip& clip, const GrPaint& paint, - GrAA aa, const SkMatrix& viewMatrix, const SkRect& rect, const GrStyle* style) { @@ -549,7 +569,7 @@ void GrRenderTargetContext::drawRect(const GrClip& clip, } } - if (this->drawFilledRect(clip, paint, aa, viewMatrix, rect, nullptr)) { + if (this->drawFilledRect(clip, paint, viewMatrix, rect, nullptr)) { return; } } else if (stroke.getStyle() == SkStrokeRec::kStroke_Style || @@ -560,7 +580,7 @@ void GrRenderTargetContext::drawRect(const GrClip& clip, // TODO: Move these stroke->fill fallbacks to GrShape? switch (stroke.getJoin()) { case SkPaint::kMiter_Join: - this->drawRect(clip, paint, aa, viewMatrix, + this->drawRect(clip, paint, viewMatrix, {rect.fLeft - r, rect.fTop - r, rect.fRight + r, rect.fBottom + r}, &GrStyle::SimpleFill()); @@ -569,16 +589,16 @@ void GrRenderTargetContext::drawRect(const GrClip& clip, // Raster draws nothing when both dimensions are empty. if (rect.width() || rect.height()){ SkRRect rrect = SkRRect::MakeRectXY(rect.makeOutset(r, r), r, r); - this->drawRRect(clip, paint, aa, viewMatrix, rrect, GrStyle::SimpleFill()); + this->drawRRect(clip, paint, viewMatrix, rrect, GrStyle::SimpleFill()); return; } case SkPaint::kBevel_Join: if (!rect.width()) { - this->drawRect(clip, paint, aa, viewMatrix, + this->drawRect(clip, paint, viewMatrix, {rect.fLeft - r, rect.fTop, rect.fRight + r, rect.fBottom}, &GrStyle::SimpleFill()); } else { - this->drawRect(clip, paint, aa, viewMatrix, + this->drawRect(clip, paint, viewMatrix, {rect.fLeft, rect.fTop - r, rect.fRight, rect.fBottom + r}, &GrStyle::SimpleFill()); } @@ -586,12 +606,12 @@ void GrRenderTargetContext::drawRect(const GrClip& clip, } } + bool useHWAA; bool snapToPixelCenters = false; sk_sp<GrDrawOp> op; GrColor color = paint.getColor(); - GrAAType aaType = this->decideAAType(aa); - if (GrAAType::kCoverage == aaType) { + if (should_apply_coverage_aa(paint, fRenderTargetProxy.get(), &useHWAA)) { // The stroke path needs the rect to remain axis aligned (no rotation or skew). if (viewMatrix.rectStaysRect()) { op.reset(GrRectBatchFactory::CreateAAStroke(color, viewMatrix, rect, stroke)); @@ -607,7 +627,7 @@ void GrRenderTargetContext::drawRect(const GrClip& clip, } if (op) { - GrPipelineBuilder pipelineBuilder(paint, aaType); + GrPipelineBuilder pipelineBuilder(paint, useHWAA); if (snapToPixelCenters) { pipelineBuilder.setState(GrPipelineBuilder::kSnapVerticesToPixelCenters_Flag, @@ -622,7 +642,7 @@ void GrRenderTargetContext::drawRect(const GrClip& clip, SkPath path; path.setIsVolatile(true); path.addRect(rect); - this->internalDrawPath(clip, paint, aa, viewMatrix, path, *style); + this->internalDrawPath(clip, paint, viewMatrix, path, *style); } int GrRenderTargetContextPriv::maxWindowRectangles() const { @@ -646,17 +666,16 @@ void GrRenderTargetContextPriv::clearStencilClip(const GrFixedClip& clip, bool i } void GrRenderTargetContextPriv::stencilPath(const GrClip& clip, - GrAAType aaType, + bool useHWAA, const SkMatrix& viewMatrix, const GrPath* path) { - SkASSERT(aaType != GrAAType::kCoverage); - fRenderTargetContext->getOpList()->stencilPath(fRenderTargetContext, clip, aaType, viewMatrix, + fRenderTargetContext->getOpList()->stencilPath(fRenderTargetContext, clip, useHWAA, viewMatrix, path); } void GrRenderTargetContextPriv::stencilRect(const GrClip& clip, const GrUserStencilSettings* ss, - GrAAType aaType, + bool useHWAA, const SkMatrix& viewMatrix, const SkRect& rect) { ASSERT_SINGLE_OWNER_PRIV @@ -664,21 +683,22 @@ void GrRenderTargetContextPriv::stencilRect(const GrClip& clip, SkDEBUGCODE(fRenderTargetContext->validate();) GR_AUDIT_TRAIL_AUTO_FRAME(fRenderTargetContext->fAuditTrail, "GrRenderTargetContext::stencilRect"); - SkASSERT(GrAAType::kCoverage != aaType); + AutoCheckFlush acf(fRenderTargetContext->fDrawingManager); GrPaint paint; + paint.setAntiAlias(useHWAA); paint.setXPFactory(GrDisableColorXPFactory::Make()); fRenderTargetContext->drawNonAAFilledRect(clip, paint, viewMatrix, rect, nullptr, nullptr, ss, - aaType); + useHWAA); } bool GrRenderTargetContextPriv::drawAndStencilRect(const GrClip& clip, const GrUserStencilSettings* ss, SkRegion::Op op, bool invert, - GrAA aa, + bool doAA, const SkMatrix& viewMatrix, const SkRect& rect) { ASSERT_SINGLE_OWNER_PRIV @@ -690,20 +710,21 @@ bool GrRenderTargetContextPriv::drawAndStencilRect(const GrClip& clip, AutoCheckFlush acf(fRenderTargetContext->fDrawingManager); GrPaint paint; + paint.setAntiAlias(doAA); paint.setCoverageSetOpXPFactory(op, invert); - if (fRenderTargetContext->drawFilledRect(clip, paint, aa, viewMatrix, rect, ss)) { + if (fRenderTargetContext->drawFilledRect(clip, paint, viewMatrix, rect, ss)) { return true; } + SkPath path; path.setIsVolatile(true); path.addRect(rect); - return this->drawAndStencilPath(clip, ss, op, invert, aa, viewMatrix, path); + return this->drawAndStencilPath(clip, ss, op, invert, doAA, viewMatrix, path); } void GrRenderTargetContext::fillRectToRect(const GrClip& clip, const GrPaint& paint, - GrAA aa, const SkMatrix& viewMatrix, const SkRect& rectToDraw, const SkRect& localRect) { @@ -720,30 +741,30 @@ void GrRenderTargetContext::fillRectToRect(const GrClip& clip, } AutoCheckFlush acf(fDrawingManager); - GrAAType aaType; + bool useHWAA; if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport()) { InstancedRendering* ir = this->getOpList()->instancedRendering(); sk_sp<GrDrawOp> op(ir->recordRect(croppedRect, viewMatrix, paint.getColor(), - croppedLocalRect, aa, fInstancedPipelineInfo, &aaType)); + croppedLocalRect, paint.isAntiAlias(), + fInstancedPipelineInfo, &useHWAA)); if (op) { - GrPipelineBuilder pipelineBuilder(paint, aaType); + GrPipelineBuilder pipelineBuilder(paint, useHWAA); this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get()); return; } } - aaType = this->decideAAType(aa); - if (GrAAType::kCoverage != aaType) { - this->drawNonAAFilledRect(clip, paint, viewMatrix, croppedRect, &croppedLocalRect, nullptr, - nullptr, aaType); + if (!should_apply_coverage_aa(paint, fRenderTargetProxy.get(), &useHWAA)) { + this->drawNonAAFilledRect(clip, paint, viewMatrix, croppedRect, &croppedLocalRect, + nullptr, nullptr, useHWAA); return; } if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) { sk_sp<GrDrawOp> op(GrAAFillRectBatch::CreateWithLocalRect(paint.getColor(), viewMatrix, croppedRect, croppedLocalRect)); - GrPipelineBuilder pipelineBuilder(paint, aaType); + GrPipelineBuilder pipelineBuilder(paint, useHWAA); this->addDrawOp(pipelineBuilder, clip, op.get()); return; } @@ -758,12 +779,11 @@ void GrRenderTargetContext::fillRectToRect(const GrClip& clip, SkPath path; path.setIsVolatile(true); path.addRect(localRect); - this->internalDrawPath(clip, paint, aa, viewAndUnLocalMatrix, path, GrStyle()); + this->internalDrawPath(clip, paint, viewAndUnLocalMatrix, path, GrStyle()); } void GrRenderTargetContext::fillRectWithLocalMatrix(const GrClip& clip, const GrPaint& paint, - GrAA aa, const SkMatrix& viewMatrix, const SkRect& rectToDraw, const SkMatrix& localMatrix) { @@ -778,30 +798,29 @@ void GrRenderTargetContext::fillRectWithLocalMatrix(const GrClip& clip, } AutoCheckFlush acf(fDrawingManager); - GrAAType aaType; + bool useHWAA; if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport()) { InstancedRendering* ir = this->getOpList()->instancedRendering(); sk_sp<GrDrawOp> op(ir->recordRect(croppedRect, viewMatrix, paint.getColor(), localMatrix, - aa, fInstancedPipelineInfo, &aaType)); + paint.isAntiAlias(), fInstancedPipelineInfo, &useHWAA)); if (op) { - GrPipelineBuilder pipelineBuilder(paint, aaType); + GrPipelineBuilder pipelineBuilder(paint, useHWAA); this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get()); return; } } - aaType = this->decideAAType(aa); - if (GrAAType::kCoverage != aaType) { - this->drawNonAAFilledRect(clip, paint, viewMatrix, croppedRect, nullptr, &localMatrix, - nullptr, aaType); + if (!should_apply_coverage_aa(paint, fRenderTargetProxy.get(), &useHWAA)) { + this->drawNonAAFilledRect(clip, paint, viewMatrix, croppedRect, nullptr, + &localMatrix, nullptr, useHWAA); return; } if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) { sk_sp<GrDrawOp> op(GrAAFillRectBatch::Create(paint.getColor(), viewMatrix, localMatrix, croppedRect)); - GrPipelineBuilder pipelineBuilder(paint, aaType); + GrPipelineBuilder pipelineBuilder(paint, useHWAA); this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get()); return; } @@ -817,7 +836,7 @@ void GrRenderTargetContext::fillRectWithLocalMatrix(const GrClip& clip, path.setIsVolatile(true); path.addRect(rectToDraw); path.transform(localMatrix); - this->internalDrawPath(clip, paint, aa, viewAndUnLocalMatrix, path, GrStyle()); + this->internalDrawPath(clip, paint, viewAndUnLocalMatrix, path, GrStyle()); } void GrRenderTargetContext::drawVertices(const GrClip& clip, @@ -850,7 +869,7 @@ void GrRenderTargetContext::drawVertices(const GrClip& clip, positions, vertexCount, indices, indexCount, colors, texCoords, bounds)); - GrPipelineBuilder pipelineBuilder(paint, GrAAType::kNone); + GrPipelineBuilder pipelineBuilder(paint, this->mustUseHWAA(paint)); this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get()); } @@ -873,7 +892,7 @@ void GrRenderTargetContext::drawAtlas(const GrClip& clip, sk_sp<GrDrawOp> op(new GrDrawAtlasBatch(paint.getColor(), viewMatrix, spriteCount, xform, texRect, colors)); - GrPipelineBuilder pipelineBuilder(paint, GrAAType::kNone); + GrPipelineBuilder pipelineBuilder(paint, this->mustUseHWAA(paint)); this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get()); } @@ -881,7 +900,6 @@ void GrRenderTargetContext::drawAtlas(const GrClip& clip, void GrRenderTargetContext::drawRRect(const GrClip& origClip, const GrPaint& paint, - GrAA aa, const SkMatrix& viewMatrix, const SkRRect& rrect, const GrStyle& style) { @@ -910,22 +928,21 @@ void GrRenderTargetContext::drawRRect(const GrClip& origClip, AutoCheckFlush acf(fDrawingManager); const SkStrokeRec stroke = style.strokeRec(); - GrAAType aaType; + bool useHWAA; if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport() && stroke.isFillStyle()) { InstancedRendering* ir = this->getOpList()->instancedRendering(); - sk_sp<GrDrawOp> op(ir->recordRRect(rrect, viewMatrix, paint.getColor(), aa, - fInstancedPipelineInfo, &aaType)); + sk_sp<GrDrawOp> op(ir->recordRRect(rrect, viewMatrix, paint.getColor(), paint.isAntiAlias(), + fInstancedPipelineInfo, &useHWAA)); if (op) { - GrPipelineBuilder pipelineBuilder(paint, aaType); + GrPipelineBuilder pipelineBuilder(paint, useHWAA); this->getOpList()->addDrawOp(pipelineBuilder, this, *clip, op.get()); return; } } - aaType = this->decideAAType(aa); - if (GrAAType::kCoverage == aaType) { + if (should_apply_coverage_aa(paint, fRenderTargetProxy.get(), &useHWAA)) { const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps(); sk_sp<GrDrawOp> op(GrOvalRenderer::CreateRRectBatch(paint.getColor(), paint.usesDistanceVectorField(), @@ -934,7 +951,7 @@ void GrRenderTargetContext::drawRRect(const GrClip& origClip, stroke, shaderCaps)); if (op) { - GrPipelineBuilder pipelineBuilder(paint, aaType); + GrPipelineBuilder pipelineBuilder(paint, useHWAA); this->getOpList()->addDrawOp(pipelineBuilder, this, *clip, op.get()); return; } @@ -943,7 +960,7 @@ void GrRenderTargetContext::drawRRect(const GrClip& origClip, SkPath path; path.setIsVolatile(true); path.addRRect(rrect); - this->internalDrawPath(*clip, paint, aa, viewMatrix, path, style); + this->internalDrawPath(*clip, paint, viewMatrix, path, style); } /////////////////////////////////////////////////////////////////////////////// @@ -966,55 +983,72 @@ void GrRenderTargetContext::drawShadowRRect(const GrClip& clip, AutoCheckFlush acf(fDrawingManager); const SkStrokeRec stroke = style.strokeRec(); - // TODO: add instancing support? - - const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps(); - sk_sp<GrDrawOp> op(CreateShadowRRectBatch(paint.getColor(), - viewMatrix, - rrect, - blurRadius, - stroke, - shaderCaps)); - if (op) { - GrPipelineBuilder pipelineBuilder(paint, GrAAType::kNone); - this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get()); - return; + bool useHWAA; + + // TODO: add instancing support + //if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport() && + // stroke.isFillStyle()) { + // InstancedRendering* ir = this->getOpList()->instancedRendering(); + // SkAutoTUnref<GrDrawOp> op(ir->recordRRect(rrect, viewMatrix, paint.getColor(), + // paint.isAntiAlias(), fInstancedPipelineInfo, + // &useHWAA)); + // if (op) { + // GrPipelineBuilder pipelineBuilder(paint, useHWAA); + // this->getOpList()->addDrawOp(pipelineBuilder, this, *clip, op); + // return; + // } + //} + + if (should_apply_coverage_aa(paint, fRenderTargetProxy.get(), &useHWAA)) { + const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps(); + sk_sp<GrDrawOp> op(CreateShadowRRectBatch(paint.getColor(), + viewMatrix, + rrect, + blurRadius, + stroke, + shaderCaps)); + if (op) { + GrPipelineBuilder pipelineBuilder(paint, useHWAA); + this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get()); + return; + } } + + SkPath path; + path.setIsVolatile(true); + path.addRRect(rrect); + this->internalDrawPath(clip, paint, viewMatrix, path, style); } /////////////////////////////////////////////////////////////////////////////// bool GrRenderTargetContext::drawFilledDRRect(const GrClip& clip, const GrPaint& paintIn, - GrAA aa, const SkMatrix& viewMatrix, const SkRRect& origOuter, const SkRRect& origInner) { SkASSERT(!origInner.isEmpty()); SkASSERT(!origOuter.isEmpty()); - GrAAType aaType; if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport()) { + bool useHWAA; InstancedRendering* ir = this->getOpList()->instancedRendering(); sk_sp<GrDrawOp> op(ir->recordDRRect(origOuter, origInner, viewMatrix, paintIn.getColor(), - aa, fInstancedPipelineInfo, &aaType)); + paintIn.isAntiAlias(), fInstancedPipelineInfo, + &useHWAA)); if (op) { - GrPipelineBuilder pipelineBuilder(paintIn, aaType); + GrPipelineBuilder pipelineBuilder(paintIn, useHWAA); this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get()); return true; } } - aaType = this->decideAAType(aa); + bool applyAA = paintIn.isAntiAlias() && !fRenderTargetProxy->isUnifiedMultisampled(); - GrPrimitiveEdgeType innerEdgeType, outerEdgeType; - if (GrAAType::kCoverage == aaType) { - innerEdgeType = kInverseFillAA_GrProcessorEdgeType; - outerEdgeType = kFillAA_GrProcessorEdgeType; - } else { - innerEdgeType = kInverseFillBW_GrProcessorEdgeType; - outerEdgeType = kFillBW_GrProcessorEdgeType; - } + GrPrimitiveEdgeType innerEdgeType = applyAA ? kInverseFillAA_GrProcessorEdgeType : + kInverseFillBW_GrProcessorEdgeType; + GrPrimitiveEdgeType outerEdgeType = applyAA ? kFillAA_GrProcessorEdgeType : + kFillBW_GrProcessorEdgeType; SkTCopyOnFirstWrite<SkRRect> inner(origInner), outer(origOuter); SkMatrix inverseVM; @@ -1033,6 +1067,7 @@ bool GrRenderTargetContext::drawFilledDRRect(const GrClip& clip, } GrPaint grPaint(paintIn); + grPaint.setAntiAlias(false); // TODO these need to be a geometry processors sk_sp<GrFragmentProcessor> innerEffect(GrRRectEffect::Make(innerEdgeType, *inner)); @@ -1049,17 +1084,16 @@ bool GrRenderTargetContext::drawFilledDRRect(const GrClip& clip, grPaint.addCoverageFragmentProcessor(std::move(outerEffect)); SkRect bounds = outer->getBounds(); - if (GrAAType::kCoverage == aaType) { + if (applyAA) { bounds.outset(SK_ScalarHalf, SK_ScalarHalf); } - this->fillRectWithLocalMatrix(clip, grPaint, GrAA::kNo, SkMatrix::I(), bounds, inverseVM); + this->fillRectWithLocalMatrix(clip, grPaint, SkMatrix::I(), bounds, inverseVM); return true; } void GrRenderTargetContext::drawDRRect(const GrClip& clip, const GrPaint& paint, - GrAA aa, const SkMatrix& viewMatrix, const SkRRect& outer, const SkRRect& inner) { @@ -1073,7 +1107,7 @@ void GrRenderTargetContext::drawDRRect(const GrClip& clip, AutoCheckFlush acf(fDrawingManager); - if (this->drawFilledDRRect(clip, paint, aa, viewMatrix, outer, inner)) { + if (this->drawFilledDRRect(clip, paint, viewMatrix, outer, inner)) { return; } @@ -1083,7 +1117,7 @@ void GrRenderTargetContext::drawDRRect(const GrClip& clip, path.addRRect(outer); path.setFillType(SkPath::kEvenOdd_FillType); - this->internalDrawPath(clip, paint, aa, viewMatrix, path, GrStyle::SimpleFill()); + this->internalDrawPath(clip, paint, viewMatrix, path, GrStyle::SimpleFill()); } /////////////////////////////////////////////////////////////////////////////// @@ -1094,7 +1128,6 @@ static inline bool is_int(float x) { void GrRenderTargetContext::drawRegion(const GrClip& clip, const GrPaint& paint, - GrAA aa, const SkMatrix& viewMatrix, const SkRegion& region, const GrStyle& style) { @@ -1103,30 +1136,28 @@ void GrRenderTargetContext::drawRegion(const GrClip& clip, SkDEBUGCODE(this->validate();) GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrRenderTargetContext::drawRegion"); - if (GrAA::kYes == aa) { + bool needsAA = false; + if (paint.isAntiAlias()) { // GrRegionBatch performs no antialiasing but is much faster, so here we check the matrix // to see whether aa is really required. - if (!SkToBool(viewMatrix.getType() & ~(SkMatrix::kTranslate_Mask)) && - is_int(viewMatrix.getTranslateX()) && - is_int(viewMatrix.getTranslateY())) { - aa = GrAA::kNo; - } + needsAA = SkToBool(viewMatrix.getType() & ~(SkMatrix::kTranslate_Mask)) || + !is_int(viewMatrix.getTranslateX()) || + !is_int(viewMatrix.getTranslateY()); } bool complexStyle = !style.isSimpleFill(); - if (complexStyle || GrAA::kYes == aa) { + if (complexStyle || needsAA) { SkPath path; region.getBoundaryPath(&path); - return this->drawPath(clip, paint, aa, viewMatrix, path, style); + return this->drawPath(clip, paint, viewMatrix, path, style); } sk_sp<GrDrawOp> op(GrRegionBatch::Create(paint.getColor(), viewMatrix, region)); - GrPipelineBuilder pipelineBuilder(paint, GrAAType::kNone); + GrPipelineBuilder pipelineBuilder(paint, false); this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get()); } void GrRenderTargetContext::drawOval(const GrClip& clip, const GrPaint& paint, - GrAA aa, const SkMatrix& viewMatrix, const SkRect& oval, const GrStyle& style) { @@ -1143,22 +1174,21 @@ void GrRenderTargetContext::drawOval(const GrClip& clip, AutoCheckFlush acf(fDrawingManager); const SkStrokeRec& stroke = style.strokeRec(); - GrAAType aaType; + bool useHWAA; if (GrCaps::InstancedSupport::kNone != fContext->caps()->instancedSupport() && stroke.isFillStyle()) { InstancedRendering* ir = this->getOpList()->instancedRendering(); - sk_sp<GrDrawOp> op(ir->recordOval(oval, viewMatrix, paint.getColor(), aa, - fInstancedPipelineInfo, &aaType)); + sk_sp<GrDrawOp> op(ir->recordOval(oval, viewMatrix, paint.getColor(), paint.isAntiAlias(), + fInstancedPipelineInfo, &useHWAA)); if (op) { - GrPipelineBuilder pipelineBuilder(paint, aaType); + GrPipelineBuilder pipelineBuilder(paint, useHWAA); this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get()); return; } } - aaType = this->decideAAType(aa); - if (GrAAType::kCoverage == aaType) { + if (should_apply_coverage_aa(paint, fRenderTargetProxy.get(), &useHWAA)) { const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps(); sk_sp<GrDrawOp> op(GrOvalRenderer::CreateOvalBatch(paint.getColor(), viewMatrix, @@ -1166,7 +1196,7 @@ void GrRenderTargetContext::drawOval(const GrClip& clip, stroke, shaderCaps)); if (op) { - GrPipelineBuilder pipelineBuilder(paint, aaType); + GrPipelineBuilder pipelineBuilder(paint, useHWAA); this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get()); return; } @@ -1175,20 +1205,19 @@ void GrRenderTargetContext::drawOval(const GrClip& clip, SkPath path; path.setIsVolatile(true); path.addOval(oval); - this->internalDrawPath(clip, paint, aa, viewMatrix, path, style); + this->internalDrawPath(clip, paint, viewMatrix, path, style); } void GrRenderTargetContext::drawArc(const GrClip& clip, const GrPaint& paint, - GrAA aa, const SkMatrix& viewMatrix, const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle, bool useCenter, const GrStyle& style) { - GrAAType aaType = this->decideAAType(aa); - if (GrAAType::kCoverage == aaType) { + bool useHWAA; + if (should_apply_coverage_aa(paint, fRenderTargetProxy.get(), &useHWAA)) { const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps(); sk_sp<GrDrawOp> op(GrOvalRenderer::CreateArcBatch(paint.getColor(), viewMatrix, @@ -1199,7 +1228,7 @@ void GrRenderTargetContext::drawArc(const GrClip& clip, style, shaderCaps)); if (op) { - GrPipelineBuilder pipelineBuilder(paint, aaType); + GrPipelineBuilder pipelineBuilder(paint, useHWAA); this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get()); return; } @@ -1207,7 +1236,8 @@ void GrRenderTargetContext::drawArc(const GrClip& clip, SkPath path; SkPathPriv::CreateDrawArcPath(&path, oval, startAngle, sweepAngle, useCenter, style.isSimpleFill()); - this->internalDrawPath(clip, paint, aa, viewMatrix, path, style); + this->internalDrawPath(clip, paint, viewMatrix, path, style); + return; } void GrRenderTargetContext::drawImageLattice(const GrClip& clip, @@ -1227,7 +1257,7 @@ void GrRenderTargetContext::drawImageLattice(const GrClip& clip, sk_sp<GrDrawOp> op(GrNinePatch::CreateNonAA(paint.getColor(), viewMatrix, imageWidth, imageHeight, std::move(iter), dst)); - GrPipelineBuilder pipelineBuilder(paint, GrAAType::kNone); + GrPipelineBuilder pipelineBuilder(paint, this->mustUseHWAA(paint)); this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get()); } @@ -1256,12 +1286,11 @@ void GrRenderTargetContext::drawNonAAFilledRect(const GrClip& clip, const SkRect* localRect, const SkMatrix* localMatrix, const GrUserStencilSettings* ss, - GrAAType hwOrNoneAAType) { - SkASSERT(GrAAType::kCoverage != hwOrNoneAAType); - SkASSERT(hwOrNoneAAType == GrAAType::kNone || this->isStencilBufferMultisampled()); + bool useHWAA) { + SkASSERT(!useHWAA || this->isStencilBufferMultisampled()); sk_sp<GrDrawOp> op( GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rect, localRect, localMatrix)); - GrPipelineBuilder pipelineBuilder(paint, hwOrNoneAAType); + GrPipelineBuilder pipelineBuilder(paint, useHWAA); if (ss) { pipelineBuilder.setUserStencil(ss); } @@ -1363,7 +1392,6 @@ static bool fills_as_nested_rects(const SkMatrix& viewMatrix, const SkPath& path void GrRenderTargetContext::drawPath(const GrClip& clip, const GrPaint& paint, - GrAA aa, const SkMatrix& viewMatrix, const SkPath& path, const GrStyle& style) { @@ -1381,8 +1409,9 @@ void GrRenderTargetContext::drawPath(const GrClip& clip, AutoCheckFlush acf(fDrawingManager); - GrAAType aaType = this->decideAAType(aa); - if (GrAAType::kCoverage == aaType && !style.pathEffect()) { + bool useHWAA; + if (should_apply_coverage_aa(paint, fRenderTargetProxy.get(), &useHWAA) && + !style.pathEffect()) { if (style.isSimpleFill() && !path.isConvex()) { // Concave AA paths are expensive - try to avoid them for special cases SkRect rects[2]; @@ -1390,8 +1419,8 @@ void GrRenderTargetContext::drawPath(const GrClip& clip, if (fills_as_nested_rects(viewMatrix, path, rects)) { sk_sp<GrDrawOp> op(GrRectBatchFactory::CreateAAFillNestedRects( paint.getColor(), viewMatrix, rects)); - if (op) { - GrPipelineBuilder pipelineBuilder(paint, aaType); + if (op) { + GrPipelineBuilder pipelineBuilder(paint, useHWAA); this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get()); } return; @@ -1408,7 +1437,7 @@ void GrRenderTargetContext::drawPath(const GrClip& clip, style.strokeRec(), shaderCaps)); if (op) { - GrPipelineBuilder pipelineBuilder(paint, aaType); + GrPipelineBuilder pipelineBuilder(paint, useHWAA); this->getOpList()->addDrawOp(pipelineBuilder, this, clip, op.get()); return; } @@ -1420,24 +1449,23 @@ void GrRenderTargetContext::drawPath(const GrClip& clip, // cache. This presents a potential hazard for buffered drawing. However, // the writePixels that uploads to the scratch will perform a flush so we're // OK. - this->internalDrawPath(clip, paint, aa, viewMatrix, path, style); + this->internalDrawPath(clip, paint, viewMatrix, path, style); } bool GrRenderTargetContextPriv::drawAndStencilPath(const GrClip& clip, const GrUserStencilSettings* ss, SkRegion::Op op, bool invert, - GrAA aa, + bool doAA, const SkMatrix& viewMatrix, const SkPath& path) { ASSERT_SINGLE_OWNER_PRIV RETURN_FALSE_IF_ABANDONED_PRIV SkDEBUGCODE(fRenderTargetContext->validate();) - GR_AUDIT_TRAIL_AUTO_FRAME(fRenderTargetContext->fAuditTrail, - "GrRenderTargetContextPriv::drawAndStencilPath"); + GR_AUDIT_TRAIL_AUTO_FRAME(fRenderTargetContext->fAuditTrail, "GrRenderTargetContext::drawPath"); if (path.isEmpty() && path.isInverseFillType()) { - this->drawAndStencilRect(clip, ss, op, invert, GrAA::kNo, SkMatrix::I(), + this->drawAndStencilRect(clip, ss, op, invert, false, SkMatrix::I(), SkRect::MakeIWH(fRenderTargetContext->width(), fRenderTargetContext->height())); return true; @@ -1449,12 +1477,13 @@ bool GrRenderTargetContextPriv::drawAndStencilPath(const GrClip& clip, // 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 // thing WRT to the blend then we'll need some query on the PR. - GrAAType aaType = fRenderTargetContext->decideAAType(aa); + bool useCoverageAA = doAA && !fRenderTargetContext->isUnifiedMultisampled(); bool hasUserStencilSettings = !ss->isUnused(); + bool isStencilBufferMSAA = fRenderTargetContext->isStencilBufferMultisampled(); - const GrPathRendererChain::DrawType type = (GrAAType::kCoverage == aaType) - ? GrPathRendererChain::kColorAntiAlias_DrawType - : GrPathRendererChain::kColor_DrawType; + const GrPathRendererChain::DrawType type = + useCoverageAA ? GrPathRendererChain::kColorAntiAlias_DrawType + : GrPathRendererChain::kColor_DrawType; GrShape shape(path, GrStyle::SimpleFill()); GrPathRenderer::CanDrawPathArgs canDrawArgs; @@ -1462,8 +1491,9 @@ bool GrRenderTargetContextPriv::drawAndStencilPath(const GrClip& clip, fRenderTargetContext->fDrawingManager->getContext()->caps()->shaderCaps(); canDrawArgs.fViewMatrix = &viewMatrix; canDrawArgs.fShape = &shape; - canDrawArgs.fAAType = aaType; + canDrawArgs.fAntiAlias = useCoverageAA; canDrawArgs.fHasUserStencilSettings = hasUserStencilSettings; + canDrawArgs.fIsStencilBufferMSAA = isStencilBufferMSAA; // Don't allow the SW renderer GrPathRenderer* pr = fRenderTargetContext->fDrawingManager->getPathRenderer(canDrawArgs, false, @@ -1484,7 +1514,7 @@ bool GrRenderTargetContextPriv::drawAndStencilPath(const GrClip& clip, args.fClip = &clip; args.fViewMatrix = &viewMatrix; args.fShape = &shape; - args.fAAType = aaType; + args.fAntiAlias = useCoverageAA; args.fGammaCorrect = fRenderTargetContext->isGammaCorrect(); pr->drawPath(args); return true; @@ -1504,71 +1534,55 @@ SkBudgeted GrRenderTargetContextPriv::isBudgeted() const { void GrRenderTargetContext::internalDrawPath(const GrClip& clip, const GrPaint& paint, - GrAA aa, const SkMatrix& viewMatrix, const SkPath& path, const GrStyle& style) { ASSERT_SINGLE_OWNER RETURN_IF_ABANDONED SkASSERT(!path.isEmpty()); - GrShape shape; - GrAAType aaType = this->decideAAType(aa, /*allowMixedSamples*/ true); - if (style.isSimpleHairline() && aaType == GrAAType::kMixedSamples) { - // NVPR cannot handle hairlines, so this will would get picked up by a different stencil and - // cover path renderer (i.e. default path renderer). The hairline renderer produces much - // smoother hairlines than MSAA. - aaType = GrAAType::kCoverage; + bool useCoverageAA = should_apply_coverage_aa(paint, fRenderTargetProxy.get()); + constexpr bool kHasUserStencilSettings = false; + bool isStencilBufferMSAA = this->isStencilBufferMultisampled(); + + const GrPathRendererChain::DrawType type = + useCoverageAA ? GrPathRendererChain::kColorAntiAlias_DrawType + : GrPathRendererChain::kColor_DrawType; + + GrShape shape(path, style); + if (shape.isEmpty()) { + return; } GrPathRenderer::CanDrawPathArgs canDrawArgs; canDrawArgs.fShaderCaps = fDrawingManager->getContext()->caps()->shaderCaps(); canDrawArgs.fViewMatrix = &viewMatrix; canDrawArgs.fShape = &shape; - canDrawArgs.fHasUserStencilSettings = false; + canDrawArgs.fAntiAlias = useCoverageAA; + canDrawArgs.fHasUserStencilSettings = kHasUserStencilSettings; + canDrawArgs.fIsStencilBufferMSAA = isStencilBufferMSAA; - GrPathRenderer* pr; - do { - const GrPathRendererChain::DrawType type = GrAAType::kCoverage == aaType - ? GrPathRendererChain::kColorAntiAlias_DrawType - : GrPathRendererChain::kColor_DrawType; + // Try a 1st time without applying any of the style to the geometry (and barring sw) + GrPathRenderer* pr = fDrawingManager->getPathRenderer(canDrawArgs, false, type); + SkScalar styleScale = GrStyle::MatrixToScaleFactor(viewMatrix); - shape = GrShape(path, style); + if (!pr && shape.style().pathEffect()) { + // It didn't work above, so try again with the path effect applied. + shape = shape.applyStyle(GrStyle::Apply::kPathEffectOnly, styleScale); if (shape.isEmpty()) { return; } - - canDrawArgs.fAAType = aaType; - - // Try a 1st time without applying any of the style to the geometry (and barring sw) pr = fDrawingManager->getPathRenderer(canDrawArgs, false, type); - SkScalar styleScale = GrStyle::MatrixToScaleFactor(viewMatrix); - - if (!pr && shape.style().pathEffect()) { - // It didn't work above, so try again with the path effect applied. - shape = shape.applyStyle(GrStyle::Apply::kPathEffectOnly, styleScale); + } + if (!pr) { + if (shape.style().applies()) { + shape = shape.applyStyle(GrStyle::Apply::kPathEffectAndStrokeRec, styleScale); if (shape.isEmpty()) { return; } - pr = fDrawingManager->getPathRenderer(canDrawArgs, false, type); - } - if (!pr) { - if (shape.style().applies()) { - shape = shape.applyStyle(GrStyle::Apply::kPathEffectAndStrokeRec, styleScale); - if (shape.isEmpty()) { - return; - } - } - // This time, allow SW renderer - pr = fDrawingManager->getPathRenderer(canDrawArgs, true, type); - } - if (!pr && (aaType == GrAAType::kMixedSamples || aaType == GrAAType::kMSAA)) { - // There are exceptional cases where we may wind up falling back to coverage based AA - // when the target is MSAA (e.g. through disabling path renderers via GrContextOptions). - aaType = GrAAType::kCoverage; - } else { - break; } - } while(true); + // This time, allow SW renderer + pr = fDrawingManager->getPathRenderer(canDrawArgs, true, type); + } if (!pr) { #ifdef SK_DEBUG @@ -1584,8 +1598,8 @@ void GrRenderTargetContext::internalDrawPath(const GrClip& clip, args.fRenderTargetContext = this; args.fClip = &clip; args.fViewMatrix = &viewMatrix; - args.fShape = &shape; - args.fAAType = aaType; + args.fShape = canDrawArgs.fShape; + args.fAntiAlias = useCoverageAA; args.fGammaCorrect = this->isGammaCorrect(); pr->drawPath(args); } diff --git a/src/gpu/GrRenderTargetContextPriv.h b/src/gpu/GrRenderTargetContextPriv.h index d53bd5634b..b2e647d70b 100644 --- a/src/gpu/GrRenderTargetContextPriv.h +++ b/src/gpu/GrRenderTargetContextPriv.h @@ -66,33 +66,28 @@ public: void stencilRect(const GrClip& clip, const GrUserStencilSettings* ss, - GrAAType, + bool useHWAA, const SkMatrix& viewMatrix, const SkRect& rect); - void stencilPath(const GrClip&, GrAAType, const SkMatrix& viewMatrix, const GrPath*); + void stencilPath(const GrClip&, + bool useHWAA, + const SkMatrix& viewMatrix, + const GrPath*); - /** - * Draws a rect, either AA or not, and touches the stencil buffer with the user stencil settings - * for each color sample written. - */ bool drawAndStencilRect(const GrClip&, const GrUserStencilSettings*, SkRegion::Op op, bool invert, - GrAA, + bool doAA, const SkMatrix& viewMatrix, const SkRect&); - /** - * Draws a path, either AA or not, and touches the stencil buffer with the user stencil settings - * for each color sample written. - */ bool drawAndStencilPath(const GrClip&, const GrUserStencilSettings*, SkRegion::Op op, bool invert, - GrAA, + bool doAA, const SkMatrix& viewMatrix, const SkPath&); @@ -109,7 +104,6 @@ public: } void testingOnly_drawBatch(const GrPaint&, - GrAAType, GrDrawOp* batch, const GrUserStencilSettings* = nullptr, bool snapToCenters = false); diff --git a/src/gpu/GrRenderTargetOpList.cpp b/src/gpu/GrRenderTargetOpList.cpp index 80b0a83610..41c0d4f9fd 100644 --- a/src/gpu/GrRenderTargetOpList.cpp +++ b/src/gpu/GrRenderTargetOpList.cpp @@ -351,10 +351,9 @@ void GrRenderTargetOpList::addDrawOp(const GrPipelineBuilder& pipelineBuilder, void GrRenderTargetOpList::stencilPath(GrRenderTargetContext* renderTargetContext, const GrClip& clip, - GrAAType aaType, + bool useHWAA, const SkMatrix& viewMatrix, const GrPath* path) { - bool useHWAA = (aaType == GrAAType::kMSAA || aaType == GrAAType::kMixedSamples); // TODO: extract portions of checkDraw that are relevant to path stenciling. SkASSERT(path); SkASSERT(this->caps()->shaderCaps()->pathRenderingSupport()); diff --git a/src/gpu/GrRenderTargetOpList.h b/src/gpu/GrRenderTargetOpList.h index 7ee4470aac..d7f8ba1bab 100644 --- a/src/gpu/GrRenderTargetOpList.h +++ b/src/gpu/GrRenderTargetOpList.h @@ -95,7 +95,7 @@ public: */ void stencilPath(GrRenderTargetContext*, const GrClip&, - GrAAType aa, + bool useHWAA, const SkMatrix& viewMatrix, const GrPath*); diff --git a/src/gpu/GrSWMaskHelper.cpp b/src/gpu/GrSWMaskHelper.cpp index 7351ecd547..ec76c48bf9 100644 --- a/src/gpu/GrSWMaskHelper.cpp +++ b/src/gpu/GrSWMaskHelper.cpp @@ -38,11 +38,12 @@ static SkBlendMode op_to_mode(SkRegion::Op op) { /** * Draw a single rect element of the clip stack into the accumulation bitmap */ -void GrSWMaskHelper::drawRect(const SkRect& rect, SkRegion::Op op, GrAA aa, uint8_t alpha) { +void GrSWMaskHelper::drawRect(const SkRect& rect, SkRegion::Op op, + bool antiAlias, uint8_t alpha) { SkPaint paint; paint.setBlendMode(op_to_mode(op)); - paint.setAntiAlias(GrAA::kYes == aa); + paint.setAntiAlias(antiAlias); paint.setColor(SkColorSetARGB(alpha, alpha, alpha, alpha)); fDraw.drawRect(rect, paint); @@ -51,11 +52,12 @@ void GrSWMaskHelper::drawRect(const SkRect& rect, SkRegion::Op op, GrAA aa, uint /** * Draw a single path element of the clip stack into the accumulation bitmap */ -void GrSWMaskHelper::drawShape(const GrShape& shape, SkRegion::Op op, GrAA aa, uint8_t alpha) { +void GrSWMaskHelper::drawShape(const GrShape& shape, SkRegion::Op op, bool antiAlias, + uint8_t alpha) { SkPaint paint; paint.setPathEffect(sk_ref_sp(shape.style().pathEffect())); shape.style().strokeRec().applyToPaint(&paint); - paint.setAntiAlias(GrAA::kYes == aa); + paint.setAntiAlias(antiAlias); SkPath path; shape.asPath(&path); @@ -139,7 +141,7 @@ void GrSWMaskHelper::toSDF(unsigned char* sdf) { GrTexture* GrSWMaskHelper::DrawShapeMaskToTexture(GrTextureProvider* texProvider, const GrShape& shape, const SkIRect& resultBounds, - GrAA aa, + bool antiAlias, TextureType textureType, const SkMatrix* matrix) { GrSWMaskHelper helper(texProvider); @@ -148,7 +150,7 @@ GrTexture* GrSWMaskHelper::DrawShapeMaskToTexture(GrTextureProvider* texProvider return nullptr; } - helper.drawShape(shape, SkRegion::kReplace_Op, aa, 0xFF); + helper.drawShape(shape, SkRegion::kReplace_Op, antiAlias, 0xFF); GrTexture* texture(helper.createTexture(textureType)); if (!texture) { @@ -183,7 +185,7 @@ void GrSWMaskHelper::DrawToTargetWithShapeMask(GrTexture* texture, maskMatrix.preTranslate(SkIntToScalar(-textureOriginInDeviceSpace.fX), SkIntToScalar(-textureOriginInDeviceSpace.fY)); maskMatrix.preConcat(viewMatrix); - GrPipelineBuilder pipelineBuilder(paint, GrAAType::kNone); + GrPipelineBuilder pipelineBuilder(paint, renderTargetContext->mustUseHWAA(paint)); pipelineBuilder.setUserStencil(&userStencilSettings); pipelineBuilder.addCoverageFragmentProcessor( diff --git a/src/gpu/GrSWMaskHelper.h b/src/gpu/GrSWMaskHelper.h index 0669db9f1b..1846733dd9 100644 --- a/src/gpu/GrSWMaskHelper.h +++ b/src/gpu/GrSWMaskHelper.h @@ -9,7 +9,6 @@ #define GrSWMaskHelper_DEFINED #include "GrColor.h" -#include "GrRenderTargetContext.h" #include "GrTextureProvider.h" #include "SkAutoPixmapStorage.h" #include "SkBitmap.h" @@ -52,10 +51,10 @@ public: bool init(const SkIRect& resultBounds, const SkMatrix* matrix); // Draw a single rect into the accumulation bitmap using the specified op - void drawRect(const SkRect& rect, SkRegion::Op op, GrAA, uint8_t alpha); + void drawRect(const SkRect& rect, SkRegion::Op op, bool antiAlias, uint8_t alpha); // Draw a single path into the accumuation bitmap using the specified op - void drawShape(const GrShape&, SkRegion::Op op, GrAA, uint8_t alpha); + void drawShape(const GrShape&, SkRegion::Op op, bool antiAlias, uint8_t alpha); // Move the mask generation results from the internal bitmap to the gpu. void toTexture(GrTexture* texture); @@ -68,6 +67,7 @@ public: fPixels.erase(SkColorSetARGB(alpha, 0xFF, 0xFF, 0xFF)); } + enum class TextureType { kExactFit, kApproximateFit @@ -78,7 +78,7 @@ public: static GrTexture* DrawShapeMaskToTexture(GrTextureProvider*, const GrShape&, const SkIRect& resultBounds, - GrAA, + bool antiAlias, TextureType, const SkMatrix* matrix); diff --git a/src/gpu/GrSoftwarePathRenderer.cpp b/src/gpu/GrSoftwarePathRenderer.cpp index 73080a6ba0..8b941ebaff 100644 --- a/src/gpu/GrSoftwarePathRenderer.cpp +++ b/src/gpu/GrSoftwarePathRenderer.cpp @@ -18,8 +18,7 @@ bool GrSoftwarePathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const { // Pass on any style that applies. The caller will apply the style if a suitable renderer is // not found and try again with the new GrShape. - return !args.fShape->style().applies() && SkToBool(fTexProvider) && - (args.fAAType == GrAAType::kCoverage || args.fAAType == GrAAType::kNone); + return !args.fShape->style().applies() && SkToBool(fTexProvider); } //////////////////////////////////////////////////////////////////////////////// @@ -72,8 +71,9 @@ void GrSoftwarePathRenderer::DrawNonAARect(GrRenderTargetContext* renderTargetCo viewMatrix, rect, nullptr, &localMatrix)); - GrPipelineBuilder pipelineBuilder(paint, GrAAType::kNone); + GrPipelineBuilder pipelineBuilder(paint, renderTargetContext->mustUseHWAA(paint)); pipelineBuilder.setUserStencil(&userStencilSettings); + renderTargetContext->addDrawOp(pipelineBuilder, clip, batch.get()); } @@ -135,7 +135,7 @@ bool GrSoftwarePathRenderer::onDrawPath(const DrawPathArgs& args) { // To prevent overloading the cache with entries during animations we limit the cache of masks // to cases where the matrix preserves axis alignment. bool useCache = fAllowCaching && !inverseFilled && args.fViewMatrix->preservesAxisAlignment() && - args.fShape->hasUnstyledKey() && GrAAType::kCoverage == args.fAAType; + args.fShape->hasUnstyledKey() && args.fAntiAlias; if (!get_shape_and_clip_bounds(args.fRenderTargetContext->width(), args.fRenderTargetContext->height(), @@ -193,8 +193,6 @@ bool GrSoftwarePathRenderer::onDrawPath(const DrawPathArgs& args) { builder[3] = SkFloat2Bits(ky); builder[4] = fracX | (fracY >> 8); args.fShape->writeUnstyledKey(&builder[5]); - // FIXME: Doesn't the key need to consider whether we're using AA or not? In practice that - // should always be true, though. } sk_sp<GrTexture> texture; @@ -202,24 +200,25 @@ bool GrSoftwarePathRenderer::onDrawPath(const DrawPathArgs& args) { texture.reset(args.fResourceProvider->findAndRefTextureByUniqueKey(maskKey)); } if (!texture) { - GrSWMaskHelper::TextureType type = useCache ? GrSWMaskHelper::TextureType::kExactFit - : GrSWMaskHelper::TextureType::kApproximateFit; - GrAA aa = GrAAType::kCoverage == args.fAAType ? GrAA::kYes : GrAA::kNo; - texture.reset(GrSWMaskHelper::DrawShapeMaskToTexture(fTexProvider, *args.fShape, - *boundsForMask, aa, - type, args.fViewMatrix)); - if (!texture) { - return false; - } - if (useCache) { - texture->resourcePriv().setUniqueKey(maskKey); - } + GrSWMaskHelper::TextureType type = useCache ? GrSWMaskHelper::TextureType::kExactFit + : GrSWMaskHelper::TextureType::kApproximateFit; + texture.reset(GrSWMaskHelper::DrawShapeMaskToTexture(fTexProvider, *args.fShape, + *boundsForMask, args.fAntiAlias, + type, args.fViewMatrix)); + if (!texture) { + return false; + } + if (useCache) { + texture->resourcePriv().setUniqueKey(maskKey); + } } + GrSWMaskHelper::DrawToTargetWithShapeMask(texture.get(), args.fRenderTargetContext, *args.fPaint, *args.fUserStencilSettings, *args.fClip, *args.fViewMatrix, SkIPoint {boundsForMask->fLeft, boundsForMask->fTop}, *boundsForMask); + if (inverseFilled) { DrawAroundInvPath(args.fRenderTargetContext, *args.fPaint, *args.fUserStencilSettings, *args.fClip, diff --git a/src/gpu/GrTextureProducer.cpp b/src/gpu/GrTextureProducer.cpp index 8b64feaed3..14e2c29bb8 100644 --- a/src/gpu/GrTextureProducer.cpp +++ b/src/gpu/GrTextureProducer.cpp @@ -69,7 +69,7 @@ GrTexture* GrTextureProducer::CopyOnGpu(GrTexture* inputTexture, const SkIRect* } SkRect dstRect = SkRect::MakeIWH(copyParams.fWidth, copyParams.fHeight); - copyRTC->fillRectToRect(GrNoClip(), paint, GrAA::kNo, SkMatrix::I(), dstRect, localRect); + copyRTC->fillRectToRect(GrNoClip(), paint, SkMatrix::I(), dstRect, localRect); return copyRTC->asTexture().release(); } diff --git a/src/gpu/GrTextureToYUVPlanes.cpp b/src/gpu/GrTextureToYUVPlanes.cpp index 6268bef003..ff6c707621 100644 --- a/src/gpu/GrTextureToYUVPlanes.cpp +++ b/src/gpu/GrTextureToYUVPlanes.cpp @@ -43,7 +43,7 @@ static bool convert_texture(GrTexture* src, GrRenderTargetContext* dst, int dstW GrPaint paint; paint.setPorterDuffXPFactory(SkBlendMode::kSrc); paint.addColorFragmentProcessor(std::move(fp)); - dst->drawRect(GrNoClip(), paint, GrAA::kNo, SkMatrix::I(), SkRect::MakeIWH(dstW, dstH)); + dst->drawRect(GrNoClip(), paint, SkMatrix::I(), SkRect::MakeIWH(dstW, dstH)); return true; } diff --git a/src/gpu/GrYUVProvider.cpp b/src/gpu/GrYUVProvider.cpp index 6fbad18841..13e84dad75 100644 --- a/src/gpu/GrYUVProvider.cpp +++ b/src/gpu/GrYUVProvider.cpp @@ -147,7 +147,7 @@ sk_sp<GrTexture> GrYUVProvider::refAsTexture(GrContext* ctx, const SkRect r = SkRect::MakeIWH(yuvInfo.fSizeInfo.fSizes[SkYUVSizeInfo::kY].fWidth, yuvInfo.fSizeInfo.fSizes[SkYUVSizeInfo::kY].fHeight); - renderTargetContext->drawRect(GrNoClip(), paint, GrAA::kNo, SkMatrix::I(), r); + renderTargetContext->drawRect(GrNoClip(), paint, SkMatrix::I(), r); return renderTargetContext->asTexture(); } diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp index 8da4d63071..4e91f4a5f2 100644 --- a/src/gpu/SkGpuDevice.cpp +++ b/src/gpu/SkGpuDevice.cpp @@ -342,8 +342,7 @@ void SkGpuDevice::drawPoints(const SkDraw& draw, SkCanvas::PointMode mode, path.setIsVolatile(true); path.moveTo(pts[0]); path.lineTo(pts[1]); - fRenderTargetContext->drawPath(fClip, grPaint, GrBoolToAA(paint.isAntiAlias()), - *draw.fMatrix, path, style); + fRenderTargetContext->drawPath(fClip, grPaint, *draw.fMatrix, path, style); return; } @@ -419,13 +418,13 @@ void SkGpuDevice::drawRect(const SkDraw& draw, const SkRect& rect, const SkPaint } GrStyle style(paint); - fRenderTargetContext->drawRect(fClip, grPaint, GrBoolToAA(paint.isAntiAlias()), *draw.fMatrix, - rect, &style); + fRenderTargetContext->drawRect(fClip, grPaint, *draw.fMatrix, rect, &style); } /////////////////////////////////////////////////////////////////////////////// -void SkGpuDevice::drawRRect(const SkDraw& draw, const SkRRect& rrect, const SkPaint& paint) { +void SkGpuDevice::drawRRect(const SkDraw& draw, const SkRRect& rrect, + const SkPaint& paint) { ASSERT_SINGLE_OWNER GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawRRect", fContext.get()); CHECK_SHOULD_DRAW(draw); @@ -484,8 +483,7 @@ void SkGpuDevice::drawRRect(const SkDraw& draw, const SkRRect& rrect, const SkPa SkASSERT(!style.pathEffect()); - fRenderTargetContext->drawRRect(fClip, grPaint, GrBoolToAA(paint.isAntiAlias()), *draw.fMatrix, - rrect, style); + fRenderTargetContext->drawRRect(fClip, grPaint, *draw.fMatrix, rrect, style); } @@ -512,8 +510,7 @@ void SkGpuDevice::drawDRRect(const SkDraw& draw, const SkRRect& outer, return; } - fRenderTargetContext->drawDRRect(fClip, grPaint, GrBoolToAA(paint.isAntiAlias()), - *draw.fMatrix, outer, inner); + fRenderTargetContext->drawDRRect(fClip, grPaint, *draw.fMatrix, outer, inner); return; } @@ -545,8 +542,7 @@ void SkGpuDevice::drawRegion(const SkDraw& draw, const SkRegion& region, const S return; } - fRenderTargetContext->drawRegion(fClip, grPaint, GrBoolToAA(paint.isAntiAlias()), *draw.fMatrix, - region, GrStyle(paint)); + fRenderTargetContext->drawRegion(fClip, grPaint, *draw.fMatrix, region, GrStyle(paint)); } void SkGpuDevice::drawOval(const SkDraw& draw, const SkRect& oval, const SkPaint& paint) { @@ -575,8 +571,7 @@ void SkGpuDevice::drawOval(const SkDraw& draw, const SkRect& oval, const SkPaint return; } - fRenderTargetContext->drawOval(fClip, grPaint, GrBoolToAA(paint.isAntiAlias()), *draw.fMatrix, - oval, GrStyle(paint)); + fRenderTargetContext->drawOval(fClip, grPaint, *draw.fMatrix, oval, GrStyle(paint)); } void SkGpuDevice::drawArc(const SkDraw& draw, const SkRect& oval, SkScalar startAngle, @@ -595,8 +590,8 @@ void SkGpuDevice::drawArc(const SkDraw& draw, const SkRect& oval, SkScalar start return; } - fRenderTargetContext->drawArc(fClip, grPaint, GrBoolToAA(paint.isAntiAlias()), *draw.fMatrix, - oval, startAngle, sweepAngle, useCenter, GrStyle(paint)); + fRenderTargetContext->drawArc(fClip, grPaint, *draw.fMatrix, oval, startAngle, sweepAngle, + useCenter, GrStyle(paint)); } #include "SkMaskFilter.h" @@ -652,9 +647,7 @@ void SkGpuDevice::drawStrokedLine(const SkPoint points[2], return; } - fRenderTargetContext->fillRectWithLocalMatrix(fClip, grPaint, - GrBoolToAA(newPaint.isAntiAlias()), m, rect, - local); + fRenderTargetContext->fillRectWithLocalMatrix(fClip, grPaint, m, rect, local); } void SkGpuDevice::drawPath(const SkDraw& draw, const SkPath& origSrcPath, @@ -1104,10 +1097,7 @@ void SkGpuDevice::drawBitmapTile(const SkBitmap& bitmap, return; } - // Coverage-based AA would cause seams between tiles. - GrAA aa = GrBoolToAA(paint.isAntiAlias() && - fRenderTargetContext->isStencilBufferMultisampled()); - fRenderTargetContext->drawRect(fClip, grPaint, aa, viewMatrix, dstRect); + fRenderTargetContext->drawRect(fClip, grPaint, viewMatrix, dstRect); } void SkGpuDevice::drawSprite(const SkDraw& draw, const SkBitmap& bitmap, @@ -1202,7 +1192,6 @@ void SkGpuDevice::drawSpecial(const SkDraw& draw, fRenderTargetContext->fillRectToRect(fClip, grPaint, - GrBoolToAA(paint.isAntiAlias()), SkMatrix::I(), SkRect::Make(SkIRect::MakeXYWH(left + offset.fX, top + offset.fY, diff --git a/src/gpu/SkGpuDevice_drawTexture.cpp b/src/gpu/SkGpuDevice_drawTexture.cpp index fe14f8ac87..93c9f18737 100644 --- a/src/gpu/SkGpuDevice_drawTexture.cpp +++ b/src/gpu/SkGpuDevice_drawTexture.cpp @@ -213,15 +213,15 @@ void SkGpuDevice::drawTextureProducerImpl(GrTextureProducer* producer, fp, producer->isAlphaOnly(), &grPaint)) { return; } - GrAA aa = GrBoolToAA(paint.isAntiAlias()); + if (canUseTextureCoordsAsLocalCoords) { - fRenderTargetContext->fillRectToRect(clip, grPaint, aa, viewMatrix, clippedDstRect, + fRenderTargetContext->fillRectToRect(clip, grPaint, viewMatrix, clippedDstRect, clippedSrcRect); return; } if (!mf) { - fRenderTargetContext->drawRect(clip, grPaint, aa, viewMatrix, clippedDstRect); + fRenderTargetContext->drawRect(clip, grPaint, viewMatrix, clippedDstRect); return; } @@ -247,6 +247,6 @@ void SkGpuDevice::drawTextureProducerImpl(GrTextureProducer* producer, rectPath.addRect(clippedDstRect); rectPath.setIsVolatile(true); GrBlurUtils::drawPathWithMaskFilter(this->context(), fRenderTargetContext.get(), fClip, - rectPath, &grPaint, aa, viewMatrix, mf, - GrStyle::SimpleFill(), true); + rectPath, &grPaint, viewMatrix, mf, GrStyle::SimpleFill(), + true); } diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp index 4d62e6fd02..6ce9caed19 100644 --- a/src/gpu/SkGr.cpp +++ b/src/gpu/SkGr.cpp @@ -558,6 +558,7 @@ static inline bool skpaint_to_grpaint_impl(GrContext* context, SkBlendMode* primColorMode, bool primitiveIsSrc, GrPaint* grPaint) { + grPaint->setAntiAlias(skPaint.isAntiAlias()); grPaint->setAllowSRGBInputs(rtc->isGammaCorrect()); // Convert SkPaint color to 4f format, including optional linearizing and gamut conversion. diff --git a/src/gpu/batches/GrAAConvexPathRenderer.cpp b/src/gpu/batches/GrAAConvexPathRenderer.cpp index cc31f4973a..56a5e7ae14 100644 --- a/src/gpu/batches/GrAAConvexPathRenderer.cpp +++ b/src/gpu/batches/GrAAConvexPathRenderer.cpp @@ -672,7 +672,7 @@ sk_sp<GrGeometryProcessor> QuadEdgeEffect::TestCreate(GrProcessorTestData* d) { /////////////////////////////////////////////////////////////////////////////// bool GrAAConvexPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const { - return (args.fShaderCaps->shaderDerivativeSupport() && (GrAAType::kCoverage == args.fAAType) && + return (args.fShaderCaps->shaderDerivativeSupport() && args.fAntiAlias && args.fShape->style().isSimpleFill() && !args.fShape->inverseFilled() && args.fShape->knownToBeConvex()); } @@ -1002,7 +1002,7 @@ bool GrAAConvexPathRenderer::onDrawPath(const DrawPathArgs& args) { sk_sp<GrDrawOp> batch(new AAConvexPathBatch(args.fPaint->getColor(), *args.fViewMatrix, path)); - GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fAAType); + GrPipelineBuilder pipelineBuilder(*args.fPaint); pipelineBuilder.setUserStencil(args.fUserStencilSettings); args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, batch.get()); diff --git a/src/gpu/batches/GrAADistanceFieldPathRenderer.cpp b/src/gpu/batches/GrAADistanceFieldPathRenderer.cpp index 71b9000482..0aa451df86 100644 --- a/src/gpu/batches/GrAADistanceFieldPathRenderer.cpp +++ b/src/gpu/batches/GrAADistanceFieldPathRenderer.cpp @@ -90,8 +90,8 @@ bool GrAADistanceFieldPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) c if (!args.fShape->style().isSimpleFill()) { return false; } - // This does non-inverse coverage-based antialiased fills. - if (GrAAType::kCoverage != args.fAAType) { + // This does non-inverse antialiased fills. + if (!args.fAntiAlias) { return false; } // TODO: Support inverse fill @@ -128,6 +128,7 @@ public: AADistanceFieldPathBatch(GrColor color, const GrShape& shape, + bool antiAlias, const SkMatrix& viewMatrix, GrBatchAtlas* atlas, ShapeCache* shapeCache, ShapeDataList* shapeList, @@ -135,7 +136,7 @@ public: : INHERITED(ClassID()) { SkASSERT(shape.hasUnstyledKey()); fBatch.fViewMatrix = viewMatrix; - fGeoData.emplace_back(Geometry{color, shape}); + fGeoData.emplace_back(Geometry{color, shape, antiAlias}); fAtlas = atlas; fShapeCache = shapeCache; @@ -156,7 +157,7 @@ public: SkString dumpInfo() const override { SkString string; for (const auto& geo : fGeoData) { - string.appendf("Color: 0x%08x\n", geo.fColor); + string.appendf("Color: 0x%08x AA:%d\n", geo.fColor, geo.fAntiAlias); } string.append(DumpPipelineInfo(*this->pipeline())); string.append(INHERITED::dumpInfo()); @@ -273,6 +274,7 @@ private: atlas, shapeData, args.fShape, + args.fAntiAlias, desiredDimension, scale)) { delete shapeData; @@ -298,8 +300,8 @@ private: } bool addPathToAtlas(GrMeshDrawOp::Target* target, FlushInfo* flushInfo, GrBatchAtlas* atlas, - ShapeData* shapeData, const GrShape& shape, uint32_t dimension, - SkScalar scale) const { + ShapeData* shapeData, const GrShape& shape, bool antiAlias, + uint32_t dimension, SkScalar scale) const { const SkRect& bounds = shape.bounds(); // generate bounding rect for bitmap draw @@ -346,7 +348,7 @@ private: // rasterize path SkPaint paint; paint.setStyle(SkPaint::kFill_Style); - paint.setAntiAlias(true); + paint.setAntiAlias(antiAlias); SkDraw draw; sk_bzero(&draw, sizeof(draw)); @@ -500,6 +502,7 @@ private: struct Geometry { GrColor fColor; GrShape fShape; + bool fAntiAlias; }; BatchTracker fBatch; @@ -515,6 +518,8 @@ private: bool GrAADistanceFieldPathRenderer::onDrawPath(const DrawPathArgs& args) { GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(), "GrAADistanceFieldPathRenderer::onDrawPath"); + SkASSERT(!args.fRenderTargetContext->isUnifiedMultisampled()); + SkASSERT(args.fShape->style().isSimpleFill()); // we've already bailed on inverse filled paths, so this is safe SkASSERT(!args.fShape->isEmpty()); @@ -531,10 +536,11 @@ bool GrAADistanceFieldPathRenderer::onDrawPath(const DrawPathArgs& args) { } sk_sp<GrDrawOp> batch(new AADistanceFieldPathBatch(args.fPaint->getColor(), - *args.fShape, *args.fViewMatrix, + *args.fShape, + args.fAntiAlias, *args.fViewMatrix, fAtlas.get(), &fShapeCache, &fShapeList, args.fGammaCorrect)); - GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fAAType); + GrPipelineBuilder pipelineBuilder(*args.fPaint); pipelineBuilder.setUserStencil(args.fUserStencilSettings); args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, batch.get()); @@ -608,9 +614,11 @@ DRAW_BATCH_TEST_DEFINE(AADistanceFieldPathBatch) { // This path renderer only allows fill styles. GrShape shape(GrTest::TestPath(random), GrStyle::SimpleFill()); + bool antiAlias = random->nextBool(); return new AADistanceFieldPathBatch(color, shape, + antiAlias, viewMatrix, gTestStruct.fAtlas.get(), &gTestStruct.fShapeCache, diff --git a/src/gpu/batches/GrAAHairLinePathRenderer.cpp b/src/gpu/batches/GrAAHairLinePathRenderer.cpp index 732d694b45..662010f7c9 100644 --- a/src/gpu/batches/GrAAHairLinePathRenderer.cpp +++ b/src/gpu/batches/GrAAHairLinePathRenderer.cpp @@ -617,7 +617,7 @@ static void add_line(const SkPoint p[2], /////////////////////////////////////////////////////////////////////////////// bool GrAAHairLinePathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const { - if (GrAAType::kCoverage != args.fAAType) { + if (!args.fAntiAlias) { return false; } @@ -981,7 +981,7 @@ bool GrAAHairLinePathRenderer::onDrawPath(const DrawPathArgs& args) { *args.fViewMatrix, path, args.fShape->style(), devClipBounds)); - GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fAAType); + GrPipelineBuilder pipelineBuilder(*args.fPaint); pipelineBuilder.setUserStencil(args.fUserStencilSettings); args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, batch.get()); diff --git a/src/gpu/batches/GrAALinearizingConvexPathRenderer.cpp b/src/gpu/batches/GrAALinearizingConvexPathRenderer.cpp index cbf526c807..f961c5eb74 100644 --- a/src/gpu/batches/GrAALinearizingConvexPathRenderer.cpp +++ b/src/gpu/batches/GrAALinearizingConvexPathRenderer.cpp @@ -37,7 +37,7 @@ GrAALinearizingConvexPathRenderer::GrAALinearizingConvexPathRenderer() { /////////////////////////////////////////////////////////////////////////////// bool GrAALinearizingConvexPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const { - if (GrAAType::kCoverage != args.fAAType) { + if (!args.fAntiAlias) { return false; } if (!args.fShape->knownToBeConvex()) { @@ -361,7 +361,7 @@ bool GrAALinearizingConvexPathRenderer::onDrawPath(const DrawPathArgs& args) { stroke.getStyle(), join, miterLimit)); - GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fAAType); + GrPipelineBuilder pipelineBuilder(*args.fPaint); pipelineBuilder.setUserStencil(args.fUserStencilSettings); args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, batch.get()); diff --git a/src/gpu/batches/GrDashLinePathRenderer.cpp b/src/gpu/batches/GrDashLinePathRenderer.cpp index 9304885c9d..d2a420d4be 100644 --- a/src/gpu/batches/GrDashLinePathRenderer.cpp +++ b/src/gpu/batches/GrDashLinePathRenderer.cpp @@ -16,9 +16,6 @@ bool GrDashLinePathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const { SkPoint pts[2]; bool inverted; if (args.fShape->style().isDashed() && args.fShape->asLine(pts, &inverted)) { - if (args.fAAType == GrAAType::kMixedSamples) { - return false; - } // We should never have an inverse dashed case. SkASSERT(!inverted); return GrDashingEffect::CanDrawDashLine(pts, args.fShape->style(), *args.fViewMatrix); @@ -29,19 +26,16 @@ bool GrDashLinePathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const { bool GrDashLinePathRenderer::onDrawPath(const DrawPathArgs& args) { GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(), "GrDashLinePathRenderer::onDrawPath"); - GrDashingEffect::AAMode aaMode = GrDashingEffect::AAMode::kNone; - switch (args.fAAType) { - case GrAAType::kNone: - break; - case GrAAType::kCoverage: - case GrAAType::kMixedSamples: - aaMode = GrDashingEffect::AAMode::kCoverage; - break; - case GrAAType::kMSAA: - // In this mode we will use aa between dashes but the outer border uses MSAA. Otherwise, - // we can wind up with external edges antialiased and internal edges unantialiased. - aaMode = GrDashingEffect::AAMode::kCoverageWithMSAA; - break; + bool useHWAA = args.fRenderTargetContext->isUnifiedMultisampled(); + GrDashingEffect::AAMode aaMode; + if (useHWAA) { + // We ignore args.fAntiAlias here and force anti aliasing when using MSAA. Otherwise, + // we can wind up with external edges antialiased and internal edges unantialiased. + aaMode = GrDashingEffect::AAMode::kCoverageWithMSAA; + } else if (args.fAntiAlias) { + aaMode = GrDashingEffect::AAMode::kCoverage; + } else { + aaMode = GrDashingEffect::AAMode::kNone; } SkPoint pts[2]; SkAssertResult(args.fShape->asLine(pts, nullptr)); @@ -54,7 +48,7 @@ bool GrDashLinePathRenderer::onDrawPath(const DrawPathArgs& args) { return false; } - GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fAAType); + GrPipelineBuilder pipelineBuilder(*args.fPaint, useHWAA); pipelineBuilder.setUserStencil(args.fUserStencilSettings); args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, batch.get()); diff --git a/src/gpu/batches/GrDefaultPathRenderer.cpp b/src/gpu/batches/GrDefaultPathRenderer.cpp index 0b688c5305..f3f9e73155 100644 --- a/src/gpu/batches/GrDefaultPathRenderer.cpp +++ b/src/gpu/batches/GrDefaultPathRenderer.cpp @@ -424,13 +424,11 @@ private: bool GrDefaultPathRenderer::internalDrawPath(GrRenderTargetContext* renderTargetContext, const GrPaint& paint, - GrAAType aaType, const GrUserStencilSettings& userStencilSettings, const GrClip& clip, const SkMatrix& viewMatrix, const GrShape& shape, bool stencilOnly) { - SkASSERT(GrAAType::kCoverage != aaType); SkPath path; shape.asPath(&path); @@ -569,20 +567,23 @@ bool GrDefaultPathRenderer::internalDrawPath(GrRenderTargetContext* renderTarget &localMatrix)); SkASSERT(GrDrawFace::kBoth == drawFace[p]); - GrPipelineBuilder pipelineBuilder(paint, aaType); + GrPipelineBuilder pipelineBuilder(paint, renderTargetContext->mustUseHWAA(paint)); pipelineBuilder.setDrawFace(drawFace[p]); pipelineBuilder.setUserStencil(passes[p]); + renderTargetContext->addDrawOp(pipelineBuilder, clip, batch.get()); } else { sk_sp<GrDrawOp> batch(new DefaultPathBatch(paint.getColor(), path, srcSpaceTol, newCoverage, viewMatrix, isHairline, devBounds)); - GrPipelineBuilder pipelineBuilder(paint, aaType); + + GrPipelineBuilder pipelineBuilder(paint, renderTargetContext->mustUseHWAA(paint)); pipelineBuilder.setDrawFace(drawFace[p]); pipelineBuilder.setUserStencil(passes[p]); if (passCount > 1) { pipelineBuilder.setDisableColorXPFactory(); } + renderTargetContext->addDrawOp(pipelineBuilder, clip, batch.get()); } } @@ -590,8 +591,8 @@ bool GrDefaultPathRenderer::internalDrawPath(GrRenderTargetContext* renderTarget } bool GrDefaultPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const { - // This can draw any path with any simple fill style but doesn't do coverage-based antialiasing. - return GrAAType::kCoverage != args.fAAType && + // this class can draw any path with any simple fill style but doesn't do any anti-aliasing. + return !args.fAntiAlias && (args.fShape->style().isSimpleFill() || IsStrokeHairlineOrEquivalent(args.fShape->style(), *args.fViewMatrix, nullptr)); } @@ -601,7 +602,6 @@ bool GrDefaultPathRenderer::onDrawPath(const DrawPathArgs& args) { "GrDefaultPathRenderer::onDrawPath"); return this->internalDrawPath(args.fRenderTargetContext, *args.fPaint, - args.fAAType, *args.fUserStencilSettings, *args.fClip, *args.fViewMatrix, @@ -616,10 +616,10 @@ void GrDefaultPathRenderer::onStencilPath(const StencilPathArgs& args) { GrPaint paint; paint.setXPFactory(GrDisableColorXPFactory::Make()); + paint.setAntiAlias(args.fIsAA); - this->internalDrawPath(args.fRenderTargetContext, paint, args.fAAType, - GrUserStencilSettings::kUnused, *args.fClip, *args.fViewMatrix, - *args.fShape, true); + this->internalDrawPath(args.fRenderTargetContext, paint, GrUserStencilSettings::kUnused, + *args.fClip, *args.fViewMatrix, *args.fShape, true); } /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/gpu/batches/GrDefaultPathRenderer.h b/src/gpu/batches/GrDefaultPathRenderer.h index 8e192478b1..243d4e7d92 100644 --- a/src/gpu/batches/GrDefaultPathRenderer.h +++ b/src/gpu/batches/GrDefaultPathRenderer.h @@ -32,7 +32,6 @@ private: bool internalDrawPath(GrRenderTargetContext*, const GrPaint&, - GrAAType, const GrUserStencilSettings&, const GrClip&, const SkMatrix& viewMatrix, diff --git a/src/gpu/batches/GrMSAAPathRenderer.cpp b/src/gpu/batches/GrMSAAPathRenderer.cpp index 930f7f926a..f073db0a28 100644 --- a/src/gpu/batches/GrMSAAPathRenderer.cpp +++ b/src/gpu/batches/GrMSAAPathRenderer.cpp @@ -562,7 +562,6 @@ private: bool GrMSAAPathRenderer::internalDrawPath(GrRenderTargetContext* renderTargetContext, const GrPaint& paint, - GrAAType aaType, const GrUserStencilSettings& userStencilSettings, const GrClip& clip, const SkMatrix& viewMatrix, @@ -663,7 +662,7 @@ bool GrMSAAPathRenderer::internalDrawPath(GrRenderTargetContext* renderTargetCon GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewM, bounds, nullptr, &localMatrix)); - GrPipelineBuilder pipelineBuilder(paint, aaType); + GrPipelineBuilder pipelineBuilder(paint, renderTargetContext->mustUseHWAA(paint)); pipelineBuilder.setUserStencil(passes[p]); renderTargetContext->addDrawOp(pipelineBuilder, clip, batch.get()); @@ -674,11 +673,12 @@ bool GrMSAAPathRenderer::internalDrawPath(GrRenderTargetContext* renderTargetCon return false; } - GrPipelineBuilder pipelineBuilder(paint, aaType); + GrPipelineBuilder pipelineBuilder(paint, renderTargetContext->mustUseHWAA(paint)); pipelineBuilder.setUserStencil(passes[p]); if (passCount > 1) { pipelineBuilder.setDisableColorXPFactory(); } + renderTargetContext->addDrawOp(pipelineBuilder, clip, batch.get()); } } @@ -689,7 +689,7 @@ bool GrMSAAPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const { // This path renderer only fills and relies on MSAA for antialiasing. Stroked shapes are // handled by passing on the original shape and letting the caller compute the stroked shape // which will have a fill style. - return args.fShape->style().isSimpleFill() && (GrAAType::kCoverage != args.fAAType); + return args.fShape->style().isSimpleFill() && !args.fAntiAlias; } bool GrMSAAPathRenderer::onDrawPath(const DrawPathArgs& args) { @@ -704,7 +704,6 @@ bool GrMSAAPathRenderer::onDrawPath(const DrawPathArgs& args) { } return this->internalDrawPath(args.fRenderTargetContext, *args.fPaint, - args.fAAType, *args.fUserStencilSettings, *args.fClip, *args.fViewMatrix, @@ -720,10 +719,10 @@ void GrMSAAPathRenderer::onStencilPath(const StencilPathArgs& args) { GrPaint paint; paint.setXPFactory(GrDisableColorXPFactory::Make()); + paint.setAntiAlias(args.fIsAA); - this->internalDrawPath(args.fRenderTargetContext, paint, args.fAAType, - GrUserStencilSettings::kUnused, *args.fClip, *args.fViewMatrix, - *args.fShape, true); + this->internalDrawPath(args.fRenderTargetContext, paint, GrUserStencilSettings::kUnused, + *args.fClip, *args.fViewMatrix, *args.fShape, true); } /////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/gpu/batches/GrMSAAPathRenderer.h b/src/gpu/batches/GrMSAAPathRenderer.h index a112c6253b..3a70bcb059 100644 --- a/src/gpu/batches/GrMSAAPathRenderer.h +++ b/src/gpu/batches/GrMSAAPathRenderer.h @@ -23,7 +23,6 @@ private: bool internalDrawPath(GrRenderTargetContext*, const GrPaint&, - GrAAType, const GrUserStencilSettings&, const GrClip&, const SkMatrix& viewMatrix, diff --git a/src/gpu/batches/GrPLSPathRenderer.cpp b/src/gpu/batches/GrPLSPathRenderer.cpp index 269fde166c..6dd2199671 100644 --- a/src/gpu/batches/GrPLSPathRenderer.cpp +++ b/src/gpu/batches/GrPLSPathRenderer.cpp @@ -758,7 +758,7 @@ bool GrPLSPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const { // seams. Disable in the presence of even-odd for now. SkPath path; args.fShape->asPath(&path); - return args.fShaderCaps->shaderDerivativeSupport() && GrAAType::kCoverage == args.fAAType && + return args.fShaderCaps->shaderDerivativeSupport() && args.fAntiAlias && args.fShape->style().isSimpleFill() && !path.isInverseFillType() && path.getFillType() == SkPath::FillType::kWinding_FillType; } @@ -936,10 +936,13 @@ bool GrPLSPathRenderer::onDrawPath(const DrawPathArgs& args) { args.fShape->asPath(&path); sk_sp<GrDrawOp> batch(new PLSPathBatch(args.fPaint->getColor(), path, *args.fViewMatrix)); - GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fAAType); + + GrPipelineBuilder pipelineBuilder(*args.fPaint, + args.fRenderTargetContext->mustUseHWAA(*args.fPaint)); pipelineBuilder.setUserStencil(args.fUserStencilSettings); args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, batch.get()); + SkDEBUGCODE(inPLSDraw = false;) return true; diff --git a/src/gpu/batches/GrStencilAndCoverPathRenderer.cpp b/src/gpu/batches/GrStencilAndCoverPathRenderer.cpp index ac9ed9035e..97287d2c86 100644 --- a/src/gpu/batches/GrStencilAndCoverPathRenderer.cpp +++ b/src/gpu/batches/GrStencilAndCoverPathRenderer.cpp @@ -44,8 +44,11 @@ bool GrStencilAndCoverPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) c if (args.fHasUserStencilSettings) { return false; } - // doesn't do per-path AA, relies on the target having MSAA. - return (GrAAType::kCoverage != args.fAAType); + if (args.fAntiAlias) { + return args.fIsStencilBufferMSAA; + } else { + return true; // doesn't do per-path AA, relies on the target having MSAA + } } static GrPath* get_gr_path(GrResourceProvider* resourceProvider, const GrShape& shape) { @@ -77,14 +80,18 @@ static GrPath* get_gr_path(GrResourceProvider* resourceProvider, const GrShape& void GrStencilAndCoverPathRenderer::onStencilPath(const StencilPathArgs& args) { GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(), "GrStencilAndCoverPathRenderer::onStencilPath"); + SkASSERT(!args.fIsAA || args.fRenderTargetContext->isStencilBufferMultisampled()); + sk_sp<GrPath> p(get_gr_path(fResourceProvider, *args.fShape)); - args.fRenderTargetContext->priv().stencilPath(*args.fClip, args.fAAType, + args.fRenderTargetContext->priv().stencilPath(*args.fClip, args.fIsAA, *args.fViewMatrix, p.get()); } bool GrStencilAndCoverPathRenderer::onDrawPath(const DrawPathArgs& args) { GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(), "GrStencilAndCoverPathRenderer::onDrawPath"); + SkASSERT(!args.fPaint->isAntiAlias() || + args.fRenderTargetContext->isStencilBufferMultisampled()); SkASSERT(!args.fShape->style().strokeRec().isHairlineStyle()); const SkMatrix& viewMatrix = *args.fViewMatrix; @@ -118,8 +125,8 @@ bool GrStencilAndCoverPathRenderer::onDrawPath(const DrawPathArgs& args) { nullptr, &invert)); // fake inverse with a stencil and cover - args.fRenderTargetContext->priv().stencilPath(*args.fClip, args.fAAType, viewMatrix, - path.get()); + args.fRenderTargetContext->priv().stencilPath(*args.fClip, args.fPaint->isAntiAlias(), + viewMatrix, path.get()); { static constexpr GrUserStencilSettings kInvertedCoverPass( @@ -134,13 +141,10 @@ bool GrStencilAndCoverPathRenderer::onDrawPath(const DrawPathArgs& args) { GrUserStencilOp::kZero, 0xffff>() ); - // We have to suppress enabling MSAA for mixed samples or we will get seams due to - // coverage modulation along the edge where two triangles making up the rect meet. - GrAAType coverAAType = args.fAAType; - if (GrAAType::kMixedSamples == coverAAType) { - coverAAType = GrAAType::kNone; - } - GrPipelineBuilder pipelineBuilder(*args.fPaint, coverAAType); + + GrPipelineBuilder pipelineBuilder(*args.fPaint, + args.fPaint->isAntiAlias() && + !args.fRenderTargetContext->hasMixedSamples()); pipelineBuilder.setUserStencil(&kInvertedCoverPass); args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, coverBatch.get()); @@ -159,8 +163,13 @@ bool GrStencilAndCoverPathRenderer::onDrawPath(const DrawPathArgs& args) { sk_sp<GrDrawOp> batch(GrDrawPathBatch::Create(viewMatrix, args.fPaint->getColor(), path.get())); - GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fAAType); + GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fPaint->isAntiAlias()); pipelineBuilder.setUserStencil(&kCoverPass); + if (args.fAntiAlias) { + SkASSERT(args.fRenderTargetContext->isStencilBufferMultisampled()); + pipelineBuilder.enableState(GrPipelineBuilder::kHWAntialias_Flag); + } + args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, batch.get()); } diff --git a/src/gpu/batches/GrTessellatingPathRenderer.cpp b/src/gpu/batches/GrTessellatingPathRenderer.cpp index 4b3ef00193..afa9fe7148 100644 --- a/src/gpu/batches/GrTessellatingPathRenderer.cpp +++ b/src/gpu/batches/GrTessellatingPathRenderer.cpp @@ -140,7 +140,7 @@ bool GrTessellatingPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) cons if (!args.fShape->style().isSimpleFill() || args.fShape->knownToBeConvex()) { return false; } - if (GrAAType::kCoverage == args.fAAType) { + if (args.fAntiAlias) { #ifdef SK_DISABLE_SCREENSPACE_TESS_AA_PATH_RENDERER return false; #else @@ -364,10 +364,14 @@ bool GrTessellatingPathRenderer::onDrawPath(const DrawPathArgs& args) { *args.fShape, *args.fViewMatrix, clipBoundsI, - GrAAType::kCoverage == args.fAAType)); - GrPipelineBuilder pipelineBuilder(*args.fPaint, args.fAAType); + args.fAntiAlias)); + + GrPipelineBuilder pipelineBuilder(*args.fPaint, + args.fRenderTargetContext->mustUseHWAA(*args.fPaint)); pipelineBuilder.setUserStencil(args.fUserStencilSettings); + args.fRenderTargetContext->addDrawOp(pipelineBuilder, *args.fClip, batch.get()); + return true; } diff --git a/src/gpu/effects/GrConfigConversionEffect.cpp b/src/gpu/effects/GrConfigConversionEffect.cpp index f6f8334dfd..f7003121d7 100644 --- a/src/gpu/effects/GrConfigConversionEffect.cpp +++ b/src/gpu/effects/GrConfigConversionEffect.cpp @@ -237,19 +237,19 @@ void GrConfigConversionEffect::TestForPreservingPMConversions(GrContext* context paint1.addColorFragmentProcessor(std::move(pmToUPM1)); paint1.setPorterDuffXPFactory(SkBlendMode::kSrc); - readRTC->fillRectToRect(GrNoClip(), paint1, GrAA::kNo, SkMatrix::I(), kDstRect, kSrcRect); + readRTC->fillRectToRect(GrNoClip(), paint1, SkMatrix::I(), kDstRect, kSrcRect); readRTC->asTexture()->readPixels(0, 0, kSize, kSize, kConfig, firstRead); paint2.addColorFragmentProcessor(std::move(upmToPM)); paint2.setPorterDuffXPFactory(SkBlendMode::kSrc); - tempRTC->fillRectToRect(GrNoClip(), paint2, GrAA::kNo, SkMatrix::I(), kDstRect, kSrcRect); + tempRTC->fillRectToRect(GrNoClip(), paint2, SkMatrix::I(), kDstRect, kSrcRect); paint3.addColorFragmentProcessor(std::move(pmToUPM2)); paint3.setPorterDuffXPFactory(SkBlendMode::kSrc); - readRTC->fillRectToRect(GrNoClip(), paint3, GrAA::kNo, SkMatrix::I(), kDstRect, kSrcRect); + readRTC->fillRectToRect(GrNoClip(), paint3, SkMatrix::I(), kDstRect, kSrcRect); readRTC->asTexture()->readPixels(0, 0, kSize, kSize, kConfig, secondRead); diff --git a/src/gpu/instanced/InstancedRendering.cpp b/src/gpu/instanced/InstancedRendering.cpp index faecfe5eed..135a0610ad 100644 --- a/src/gpu/instanced/InstancedRendering.cpp +++ b/src/gpu/instanced/InstancedRendering.cpp @@ -22,27 +22,28 @@ InstancedRendering::InstancedRendering(GrGpu* gpu) } GrDrawOp* InstancedRendering::recordRect(const SkRect& rect, const SkMatrix& viewMatrix, - GrColor color, GrAA aa, - const GrInstancedPipelineInfo& info, GrAAType* aaType) { - return this->recordShape(ShapeType::kRect, rect, viewMatrix, color, rect, aa, info, aaType); + GrColor color, bool antialias, + const GrInstancedPipelineInfo& info, bool* useHWAA) { + return this->recordShape(ShapeType::kRect, rect, viewMatrix, color, rect, antialias, info, + useHWAA); } GrDrawOp* InstancedRendering::recordRect(const SkRect& rect, const SkMatrix& viewMatrix, - GrColor color, const SkRect& localRect, GrAA aa, - const GrInstancedPipelineInfo& info, GrAAType* aaType) { - return this->recordShape(ShapeType::kRect, rect, viewMatrix, color, localRect, aa, info, - aaType); + GrColor color, const SkRect& localRect, bool antialias, + const GrInstancedPipelineInfo& info, bool* useHWAA) { + return this->recordShape(ShapeType::kRect, rect, viewMatrix, color, localRect, antialias, info, + useHWAA); } GrDrawOp* InstancedRendering::recordRect(const SkRect& rect, const SkMatrix& viewMatrix, GrColor color, const SkMatrix& localMatrix, - GrAA aa, const GrInstancedPipelineInfo& info, - GrAAType* aaType) { + bool antialias, const GrInstancedPipelineInfo& info, + bool* useHWAA) { if (localMatrix.hasPerspective()) { return nullptr; // Perspective is not yet supported in the local matrix. } - if (Batch* batch = this->recordShape(ShapeType::kRect, rect, viewMatrix, color, rect, aa, - info, aaType)) { + if (Batch* batch = this->recordShape(ShapeType::kRect, rect, viewMatrix, color, rect, antialias, + info, useHWAA)) { batch->getSingleInstance().fInfo |= kLocalMatrix_InfoFlag; batch->appendParamsTexel(localMatrix.getScaleX(), localMatrix.getSkewX(), localMatrix.getTranslateX()); @@ -55,16 +56,17 @@ GrDrawOp* InstancedRendering::recordRect(const SkRect& rect, const SkMatrix& vie } GrDrawOp* InstancedRendering::recordOval(const SkRect& oval, const SkMatrix& viewMatrix, - GrColor color, GrAA aa, - const GrInstancedPipelineInfo& info, GrAAType* aaType) { - return this->recordShape(ShapeType::kOval, oval, viewMatrix, color, oval, aa, info, aaType); + GrColor color, bool antialias, + const GrInstancedPipelineInfo& info, bool* useHWAA) { + return this->recordShape(ShapeType::kOval, oval, viewMatrix, color, oval, antialias, info, + useHWAA); } GrDrawOp* InstancedRendering::recordRRect(const SkRRect& rrect, const SkMatrix& viewMatrix, - GrColor color, GrAA aa, - const GrInstancedPipelineInfo& info, GrAAType* aaType) { + GrColor color, bool antialias, + const GrInstancedPipelineInfo& info, bool* useHWAA) { if (Batch* batch = this->recordShape(GetRRectShapeType(rrect), rrect.rect(), viewMatrix, color, - rrect.rect(), aa, info, aaType)) { + rrect.rect(), antialias, info, useHWAA)) { batch->appendRRectParams(rrect); return batch; } @@ -73,16 +75,16 @@ GrDrawOp* InstancedRendering::recordRRect(const SkRRect& rrect, const SkMatrix& GrDrawOp* InstancedRendering::recordDRRect(const SkRRect& outer, const SkRRect& inner, const SkMatrix& viewMatrix, GrColor color, - GrAA aa, const GrInstancedPipelineInfo& info, - GrAAType* aaType) { + bool antialias, const GrInstancedPipelineInfo& info, + bool* useHWAA) { if (inner.getType() > SkRRect::kSimple_Type) { return nullptr; // Complex inner round rects are not yet supported. } if (SkRRect::kEmpty_Type == inner.getType()) { - return this->recordRRect(outer, viewMatrix, color, aa, info, aaType); + return this->recordRRect(outer, viewMatrix, color, antialias, info, useHWAA); } if (Batch* batch = this->recordShape(GetRRectShapeType(outer), outer.rect(), viewMatrix, color, - outer.rect(), aa, info, aaType)) { + outer.rect(), antialias, info, useHWAA)) { batch->appendRRectParams(outer); ShapeType innerShapeType = GetRRectShapeType(inner); batch->fInfo.fInnerShapeTypes |= GetShapeFlag(innerShapeType); @@ -97,9 +99,9 @@ GrDrawOp* InstancedRendering::recordDRRect(const SkRRect& outer, const SkRRect& InstancedRendering::Batch* InstancedRendering::recordShape(ShapeType type, const SkRect& bounds, const SkMatrix& viewMatrix, GrColor color, const SkRect& localRect, - GrAA aa, + bool antialias, const GrInstancedPipelineInfo& info, - GrAAType* aaType) { + bool* useHWAA) { SkASSERT(State::kRecordingDraws == fState); if (info.fIsRenderingToFloat && fGpu->caps()->avoidInstancedDrawsToFPTargets()) { @@ -107,7 +109,7 @@ InstancedRendering::Batch* InstancedRendering::recordShape(ShapeType type, const } AntialiasMode antialiasMode; - if (!this->selectAntialiasMode(viewMatrix, aa, info, aaType, &antialiasMode)) { + if (!this->selectAntialiasMode(viewMatrix, antialias, info, useHWAA, &antialiasMode)) { return nullptr; } @@ -191,28 +193,27 @@ InstancedRendering::Batch* InstancedRendering::recordShape(ShapeType type, const return batch; } -inline bool InstancedRendering::selectAntialiasMode(const SkMatrix& viewMatrix, GrAA aa, +inline bool InstancedRendering::selectAntialiasMode(const SkMatrix& viewMatrix, bool antialias, const GrInstancedPipelineInfo& info, - GrAAType* aaType, - AntialiasMode* antialiasMode) { + bool* useHWAA, AntialiasMode* antialiasMode) { SkASSERT(!info.fColorDisabled || info.fDrawingShapeToStencil); SkASSERT(!info.fIsMixedSampled || info.fIsMultisampled); SkASSERT(GrCaps::InstancedSupport::kNone != fGpu->caps()->instancedSupport()); if (!info.fIsMultisampled || fGpu->caps()->multisampleDisableSupport()) { - if (GrAA::kNo == aa) { + if (!antialias) { if (info.fDrawingShapeToStencil && !info.fCanDiscard) { // We can't draw to the stencil buffer without discard (or sample mask if MSAA). return false; } *antialiasMode = AntialiasMode::kNone; - *aaType = GrAAType::kNone; + *useHWAA = false; return true; } if (info.canUseCoverageAA() && viewMatrix.preservesRightAngles()) { *antialiasMode = AntialiasMode::kCoverage; - *aaType = GrAAType::kCoverage; + *useHWAA = false; return true; } } @@ -221,12 +222,12 @@ inline bool InstancedRendering::selectAntialiasMode(const SkMatrix& viewMatrix, fGpu->caps()->instancedSupport() >= GrCaps::InstancedSupport::kMultisampled) { if (!info.fIsMixedSampled || info.fColorDisabled) { *antialiasMode = AntialiasMode::kMSAA; - *aaType = GrAAType::kMSAA; + *useHWAA = true; return true; } if (fGpu->caps()->instancedSupport() >= GrCaps::InstancedSupport::kMixedSampled) { *antialiasMode = AntialiasMode::kMixedSamples; - *aaType = GrAAType::kMixedSamples; + *useHWAA = true; return true; } } diff --git a/src/gpu/instanced/InstancedRendering.h b/src/gpu/instanced/InstancedRendering.h index 903697436c..d3a01523a6 100644 --- a/src/gpu/instanced/InstancedRendering.h +++ b/src/gpu/instanced/InstancedRendering.h @@ -46,25 +46,28 @@ public: * draws between beginFlush() and endFlush(). */ GrDrawOp* SK_WARN_UNUSED_RESULT recordRect(const SkRect&, const SkMatrix&, GrColor, - GrAA, const GrInstancedPipelineInfo&, GrAAType*); + bool antialias, const GrInstancedPipelineInfo&, + bool* useHWAA); GrDrawOp* SK_WARN_UNUSED_RESULT recordRect(const SkRect&, const SkMatrix&, GrColor, - const SkRect& localRect, GrAA, - const GrInstancedPipelineInfo&, GrAAType*); + const SkRect& localRect, bool antialias, + const GrInstancedPipelineInfo&, bool* useHWAA); GrDrawOp* SK_WARN_UNUSED_RESULT recordRect(const SkRect&, const SkMatrix&, GrColor, - const SkMatrix& localMatrix, GrAA, - const GrInstancedPipelineInfo&, GrAAType*); + const SkMatrix& localMatrix, bool antialias, + const GrInstancedPipelineInfo&, bool* useHWAA); GrDrawOp* SK_WARN_UNUSED_RESULT recordOval(const SkRect&, const SkMatrix&, GrColor, - GrAA, const GrInstancedPipelineInfo&, GrAAType*); + bool antialias, const GrInstancedPipelineInfo&, + bool* useHWAA); GrDrawOp* SK_WARN_UNUSED_RESULT recordRRect(const SkRRect&, const SkMatrix&, GrColor, - GrAA, const GrInstancedPipelineInfo&, GrAAType*); + bool antialias, const GrInstancedPipelineInfo&, + bool* useHWAA); GrDrawOp* SK_WARN_UNUSED_RESULT recordDRRect(const SkRRect& outer, const SkRRect& inner, - const SkMatrix&, GrColor, GrAA, - const GrInstancedPipelineInfo&, GrAAType*); + const SkMatrix&, GrColor, bool antialias, + const GrInstancedPipelineInfo&, bool* useHWAA); /** * Compiles all recorded draws into GPU buffers and allows the client to begin flushing the @@ -179,11 +182,11 @@ private: Batch* SK_WARN_UNUSED_RESULT recordShape(ShapeType, const SkRect& bounds, const SkMatrix& viewMatrix, GrColor, - const SkRect& localRect, GrAA aa, - const GrInstancedPipelineInfo&, GrAAType*); + const SkRect& localRect, bool antialias, + const GrInstancedPipelineInfo&, bool* requireHWAA); - bool selectAntialiasMode(const SkMatrix& viewMatrix, GrAA aa, const GrInstancedPipelineInfo&, - GrAAType*, AntialiasMode*); + bool selectAntialiasMode(const SkMatrix& viewMatrix, bool antialias, + const GrInstancedPipelineInfo&, bool* useHWAA, AntialiasMode*); virtual Batch* createBatch() = 0; diff --git a/src/gpu/instanced/InstancedRenderingTypes.h b/src/gpu/instanced/InstancedRenderingTypes.h index 2ed269a8cf..97f8946d03 100644 --- a/src/gpu/instanced/InstancedRenderingTypes.h +++ b/src/gpu/instanced/InstancedRenderingTypes.h @@ -42,7 +42,6 @@ enum class Attrib : uint8_t { }; constexpr int kNumAttribs = 1 + (int)Attrib::kLocalRect; -// TODO: replace with GrAAType? enum class AntialiasMode : uint8_t { kNone, kCoverage, diff --git a/src/gpu/text/GrAtlasTextBlob.cpp b/src/gpu/text/GrAtlasTextBlob.cpp index 1fb4f2cdda..5b35f845c1 100644 --- a/src/gpu/text/GrAtlasTextBlob.cpp +++ b/src/gpu/text/GrAtlasTextBlob.cpp @@ -323,7 +323,8 @@ void GrAtlasTextBlob::flushRun(GrRenderTargetContext* rtc, const GrPaint& grPain distanceAdjustTable, rtc->isGammaCorrect(), cache)); - GrPipelineBuilder pipelineBuilder(grPaint, GrAAType::kNone); + + GrPipelineBuilder pipelineBuilder(grPaint, rtc->mustUseHWAA(grPaint)); rtc->addDrawOp(pipelineBuilder, clip, batch.get()); } diff --git a/src/gpu/text/GrStencilAndCoverTextContext.cpp b/src/gpu/text/GrStencilAndCoverTextContext.cpp index b573b83f62..ba98784c71 100644 --- a/src/gpu/text/GrStencilAndCoverTextContext.cpp +++ b/src/gpu/text/GrStencilAndCoverTextContext.cpp @@ -224,8 +224,10 @@ void GrStencilAndCoverTextContext::drawTextBlob(GrContext* context, GrRenderTarg TextBlob::Iter iter(blob); for (TextRun* run = iter.get(); run; run = iter.next()) { - run->draw(context, rtc, paint, clip, viewMatrix, props, x, y, clipBounds, - fFallbackTextContext, skPaint); + // The run's "font" overrides the anti-aliasing of the passed in paint! + paint.setAntiAlias(run->isAntiAlias()); + run->draw(context, rtc, paint, clip, viewMatrix, props, x, y, + clipBounds, fFallbackTextContext, skPaint); run->releaseGlyphCache(); } } @@ -603,9 +605,8 @@ void GrStencilAndCoverTextContext::TextRun::draw(GrContext* ctx, const SkIRect& clipBounds, GrAtlasTextContext* fallbackTextContext, const SkPaint& originalSkPaint) const { - GrAA runAA = this->isAntiAlias(); SkASSERT(fInstanceData); - SkASSERT(renderTargetContext->isStencilBufferMultisampled() || GrAA::kNo == runAA); + SkASSERT(renderTargetContext->isStencilBufferMultisampled() || !grPaint.isAntiAlias()); if (fInstanceData->count()) { static constexpr GrUserStencilSettings kCoverPass( @@ -639,16 +640,8 @@ void GrStencilAndCoverTextContext::TextRun::draw(GrContext* ctx, GrPathRendering::kWinding_FillType, glyphs.get(), fInstanceData.get(), bounds)); - // The run's "font" overrides the anti-aliasing of the passed in SkPaint! - GrAAType aaType = GrAAType::kNone; - if (GrAA::kYes == runAA) { - if (renderTargetContext->isUnifiedMultisampled()) { - aaType = GrAAType::kMSAA; - } else if (renderTargetContext->isStencilBufferMultisampled()) { - aaType = GrAAType::kMixedSamples; - } - } - GrPipelineBuilder pipelineBuilder(grPaint, aaType); + GrPipelineBuilder pipelineBuilder(grPaint); + pipelineBuilder.setState(GrPipelineBuilder::kHWAntialias_Flag, grPaint.isAntiAlias()); pipelineBuilder.setUserStencil(&kCoverPass); renderTargetContext->addDrawOp(pipelineBuilder, clip, batch.get()); diff --git a/src/gpu/text/GrStencilAndCoverTextContext.h b/src/gpu/text/GrStencilAndCoverTextContext.h index 1ba113b59b..f4773ffa5b 100644 --- a/src/gpu/text/GrStencilAndCoverTextContext.h +++ b/src/gpu/text/GrStencilAndCoverTextContext.h @@ -88,7 +88,7 @@ private: size_t computeSizeInCache() const; - GrAA isAntiAlias() const { return fFont.isAntiAlias() ? GrAA::kYes : GrAA::kNo; } + bool isAntiAlias() const { return fFont.isAntiAlias(); } private: typedef GrDrawPathRangeBatch::InstanceData InstanceData; diff --git a/src/image/SkImage_Gpu.cpp b/src/image/SkImage_Gpu.cpp index bce67e0fc4..24e5c1df83 100644 --- a/src/image/SkImage_Gpu.cpp +++ b/src/image/SkImage_Gpu.cpp @@ -277,7 +277,7 @@ static sk_sp<SkImage> make_from_yuv_textures_copy(GrContext* ctx, SkYUVColorSpac const SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height)); - renderTargetContext->drawRect(GrNoClip(), paint, GrAA::kNo, SkMatrix::I(), rect); + renderTargetContext->drawRect(GrNoClip(), paint, SkMatrix::I(), rect); if (!renderTargetContext->accessRenderTarget()) { return nullptr; diff --git a/tests/DFPathRendererTest.cpp b/tests/DFPathRendererTest.cpp index e473434bf4..327640c302 100644 --- a/tests/DFPathRendererTest.cpp +++ b/tests/DFPathRendererTest.cpp @@ -53,7 +53,7 @@ static void test_far_from_origin(GrRenderTargetContext* renderTargetContext, GrP args.fResourceProvider = rp; args.fViewMatrix = &matrix; args.fShape = &shape; - args.fAAType = GrAAType::kCoverage; + args.fAntiAlias = true; args.fGammaCorrect = false; pr->drawPath(args); } diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp index bddbee1bc4..cf4095a30b 100644 --- a/tests/GLProgramsTest.cpp +++ b/tests/GLProgramsTest.cpp @@ -255,6 +255,9 @@ static bool set_random_state(GrPaint* paint, SkRandom* random) { if (random->nextBool()) { paint->setAllowSRGBInputs(true); } + if (random->nextBool()) { + paint->setAntiAlias(true); + } return random->nextBool(); } @@ -336,13 +339,8 @@ bool GrDrawingManager::ProgramUnitTest(GrContext* context, int maxStages) { set_random_xpf(&grPaint, &ptd); bool snapToCenters = set_random_state(&grPaint, &random); const GrUserStencilSettings* uss = get_random_stencil(&random); - // We don't use kHW because we will hit an assertion if the render target is not - // multisampled - static constexpr GrAAType kAATypes[] = {GrAAType::kNone, GrAAType::kCoverage}; - GrAAType aaType = kAATypes[random.nextULessThan(SK_ARRAY_COUNT(kAATypes))]; - renderTargetContext->priv().testingOnly_drawBatch(grPaint, aaType, batch.get(), uss, - snapToCenters); + renderTargetContext->priv().testingOnly_drawBatch(grPaint, batch.get(), uss, snapToCenters); } // Flush everything, test passes if flush is successful(ie, no asserts are hit, no crashes) drawingManager->flush(); @@ -376,8 +374,7 @@ bool GrDrawingManager::ProgramUnitTest(GrContext* context, int maxStages) { BlockInputFragmentProcessor::Make(std::move(fp))); grPaint.addColorFragmentProcessor(std::move(blockFP)); - renderTargetContext->priv().testingOnly_drawBatch(grPaint, GrAAType::kNone, - batch.get()); + renderTargetContext->priv().testingOnly_drawBatch(grPaint, batch.get()); drawingManager->flush(); } } diff --git a/tests/GpuSampleLocationsTest.cpp b/tests/GpuSampleLocationsTest.cpp index 3a59e9db5f..31ada9d968 100644 --- a/tests/GpuSampleLocationsTest.cpp +++ b/tests/GpuSampleLocationsTest.cpp @@ -14,7 +14,6 @@ #include "GrRenderTargetContext.h" #include "GrRenderTargetPriv.h" -#include "GrTypesPriv.h" #include "GrPipelineBuilder.h" #include "gl/GrGLGpu.h" #include "gl/debug/DebugGLTestContext.h" @@ -91,7 +90,7 @@ public: }; static GrPipeline* construct_dummy_pipeline(GrRenderTargetContext* dc, void* storage) { - GrPipelineBuilder dummyBuilder(GrPaint(), GrAAType::kNone); + GrPipelineBuilder dummyBuilder; GrScissorState dummyScissor; GrWindowRectsState dummyWindows; GrXPOverridesForBatch dummyOverrides; diff --git a/tests/PrimitiveProcessorTest.cpp b/tests/PrimitiveProcessorTest.cpp index 17ce369580..816b4e45a2 100644 --- a/tests/PrimitiveProcessorTest.cpp +++ b/tests/PrimitiveProcessorTest.cpp @@ -127,7 +127,7 @@ DEF_GPUTEST_FOR_ALL_CONTEXTS(VertexAttributeCount, reporter, ctxInfo) { GrPaint grPaint; // This one should succeed. batch.reset(new Batch(attribCnt)); - renderTargetContext->priv().testingOnly_drawBatch(grPaint, GrAAType::kNone, batch.get()); + renderTargetContext->priv().testingOnly_drawBatch(grPaint, batch.get()); context->flush(); #if GR_GPU_STATS REPORTER_ASSERT(reporter, context->getGpu()->stats()->numDraws() == 1); @@ -136,7 +136,7 @@ DEF_GPUTEST_FOR_ALL_CONTEXTS(VertexAttributeCount, reporter, ctxInfo) { context->resetGpuStats(); // This one should fail. batch.reset(new Batch(attribCnt+1)); - renderTargetContext->priv().testingOnly_drawBatch(grPaint, GrAAType::kNone, batch.get()); + renderTargetContext->priv().testingOnly_drawBatch(grPaint, batch.get()); context->flush(); #if GR_GPU_STATS REPORTER_ASSERT(reporter, context->getGpu()->stats()->numDraws() == 0); diff --git a/tests/SRGBMipMapTest.cpp b/tests/SRGBMipMapTest.cpp index afe81678f2..b963aaff4b 100644 --- a/tests/SRGBMipMapTest.cpp +++ b/tests/SRGBMipMapTest.cpp @@ -136,13 +136,13 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SRGBMipMaps, reporter, ctxInfo) { // 1) Draw texture to S32 surface (should generate/use sRGB mips) paint.setGammaCorrect(true); - s32RenderTargetContext->drawRect(noClip, paint, GrAA::kNo, SkMatrix::I(), rect); + s32RenderTargetContext->drawRect(noClip, paint, SkMatrix::I(), rect); read_and_check_pixels(reporter, s32RenderTargetContext->asTexture().get(), expectedSRGB, error, "first render of sRGB"); // 2) Draw texture to L32 surface (should generate/use linear mips) paint.setGammaCorrect(false); - l32RenderTargetContext->drawRect(noClip, paint, GrAA::kNo, SkMatrix::I(), rect); + l32RenderTargetContext->drawRect(noClip, paint, SkMatrix::I(), rect); // Right now, this test only runs on GL (because Vulkan doesn't support legacy mip-mapping // skbug.com/5048). On GL, we may not have sRGB decode support. In that case, rendering sRGB @@ -162,7 +162,7 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SRGBMipMaps, reporter, ctxInfo) { // 3) Go back to sRGB paint.setGammaCorrect(true); - s32RenderTargetContext->drawRect(noClip, paint, GrAA::kNo, SkMatrix::I(), rect); + s32RenderTargetContext->drawRect(noClip, paint, SkMatrix::I(), rect); read_and_check_pixels(reporter, s32RenderTargetContext->asTexture().get(), expectedSRGB, error, "re-render as sRGB"); } diff --git a/tests/TessellatingPathRendererTests.cpp b/tests/TessellatingPathRendererTests.cpp index 51b8c5eaf4..db3b5ea5ca 100644 --- a/tests/TessellatingPathRendererTests.cpp +++ b/tests/TessellatingPathRendererTests.cpp @@ -267,7 +267,7 @@ static void test_path(GrRenderTargetContext* renderTargetContext, GrResourceProv args.fViewMatrix = &SkMatrix::I(); GrShape shape(path, style); args.fShape = &shape; - args.fAAType = GrAAType::kNone; + args.fAntiAlias = false; tess.drawPath(args); } diff --git a/tools/gpu/GrTest.cpp b/tools/gpu/GrTest.cpp index 43277736c1..8ab4c9be22 100644 --- a/tools/gpu/GrTest.cpp +++ b/tools/gpu/GrTest.cpp @@ -160,7 +160,7 @@ void SkGpuDevice::drawTexture(GrTexture* tex, const SkRect& dst, const SkPaint& grPaint.addColorTextureProcessor(tex, nullptr, textureMat); - fRenderTargetContext->drawRect(GrNoClip(), grPaint, GrAA::kNo, mat, dst); + fRenderTargetContext->drawRect(GrNoClip(), grPaint, mat, dst); } @@ -244,7 +244,6 @@ void GrResourceCache::changeTimestamp(uint32_t newTimestamp) { fTimestamp = newT #define RETURN_IF_ABANDONED if (fRenderTargetContext->fDrawingManager->wasAbandoned()) { return; } void GrRenderTargetContextPriv::testingOnly_drawBatch(const GrPaint& paint, - GrAAType aaType, GrDrawOp* batch, const GrUserStencilSettings* uss, bool snapToCenters) { @@ -254,7 +253,7 @@ void GrRenderTargetContextPriv::testingOnly_drawBatch(const GrPaint& paint, GR_AUDIT_TRAIL_AUTO_FRAME(fRenderTargetContext->fAuditTrail, "GrRenderTargetContext::testingOnly_drawBatch"); - GrPipelineBuilder pipelineBuilder(paint, aaType); + GrPipelineBuilder pipelineBuilder(paint, fRenderTargetContext->mustUseHWAA(paint)); if (uss) { pipelineBuilder.setUserStencil(uss); } |