Revert "Use GrOvalOpFactory ops to draw non-AA rrects, ovals, and arcs."
This reverts commit 7cdabedc8b73b70e4aa70c5621a4bdc8e00ede44.
Reason for revert: Speculative revert for causing GLProgram failure on textureBarrierSupport assert
Original change's description:
> Use GrOvalOpFactory ops to draw non-AA rrects, ovals, and arcs.
>
> This improves performance.
>
> Bug: skia:
> Change-Id: Ie01170ec084be66ea166b2baffcdb415583aa523
> Reviewed-on: https://skia-review.googlesource.com/93321
> Commit-Queue: Brian Salomon <bsalomon@google.com>
> Reviewed-by: Greg Daniel <egdaniel@google.com>
TBR=egdaniel@google.com,bsalomon@google.com
Change-Id: I327e133c889207fb682bec7d6a95f9bf1403770b
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:
Reviewed-on: https://skia-review.googlesource.com/94161
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Greg Daniel <egdaniel@google.com>
diff --git a/include/private/GrTypesPriv.h b/include/private/GrTypesPriv.h
index a379135..cfcbff9 100644
--- a/include/private/GrTypesPriv.h
+++ b/include/private/GrTypesPriv.h
@@ -9,12 +9,11 @@
#define GrTypesPriv_DEFINED
#include <chrono>
-#include "GrSharedEnums.h"
#include "GrTypes.h"
#include "SkRefCnt.h"
+#include "GrSharedEnums.h"
class GrCaps;
-class GrPaint;
// The old libstdc++ uses the draft name "monotonic_clock" rather than "steady_clock". This might
// not actually be monotonic, depending on how libstdc++ was built. However, this is only currently
@@ -88,18 +87,7 @@
*/
enum class GrAllowMixedSamples : bool { kNo = false, kYes = true };
-/**
- * We have code paths for some shapes that can draw non-AA using boolean fragment shader coverage.
- * However, it may not be desirable to use this if it will trigger a dst copy. If the caller
- * of GrChooseAAType passes GrAllowNonAABinaryCoverage::kYes and GrAA::kNo then GrChooseAAType will
- * consider whether it is efficient to use coverage to implement a non-AA draw and if so return
- * will GrAAType::kCoverage. If GrAA::kYes is passed then this value is ignored.
- */
-enum class GrAllowNonAABinaryCoverage : bool { kNo = false, kYes = true };
-
-/** GrPaint is only required if GrAllowNonAABinaryCoverage and GrAA are both kYes. */
-GrAAType GrChooseAAType(GrAA, GrFSAAType, GrAllowMixedSamples, GrAllowNonAABinaryCoverage,
- const GrPaint*, const GrCaps&);
+GrAAType GrChooseAAType(GrAA, GrFSAAType, GrAllowMixedSamples, const GrCaps&);
/**
* Some pixel configs are inherently clamped to [0,1], while others can hold values outside of that
diff --git a/src/gpu/GrClipStackClip.cpp b/src/gpu/GrClipStackClip.cpp
index 6e3fe9c..ce77369 100644
--- a/src/gpu/GrClipStackClip.cpp
+++ b/src/gpu/GrClipStackClip.cpp
@@ -124,8 +124,6 @@
canDrawArgs.fAAType = GrChooseAAType(GrAA(element->isAA()),
renderTargetContext->fsaaType(),
GrAllowMixedSamples::kYes,
- GrAllowNonAABinaryCoverage::kNo,
- nullptr,
*context->caps());
canDrawArgs.fHasUserStencilSettings = hasUserStencilSettings;
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index 16d8e1b..b0b117f 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -99,7 +99,6 @@
//////////////////////////////////////////////////////////////////////////////
GrAAType GrChooseAAType(GrAA aa, GrFSAAType fsaaType, GrAllowMixedSamples allowMixedSamples,
- GrAllowNonAABinaryCoverage allowNonAABinaryCoverage, const GrPaint* paint,
const GrCaps& caps) {
if (GrAA::kNo == aa) {
// On some devices we cannot disable MSAA if it is enabled so we make the AA type reflect
@@ -107,34 +106,6 @@
if (fsaaType == GrFSAAType::kUnifiedMSAA && !caps.multisampleDisableSupport()) {
return GrAAType::kMSAA;
}
- if (GrAllowNonAABinaryCoverage::kYes == allowNonAABinaryCoverage) {
- SkASSERT(paint);
- // If we already have a coverage FP then we won't make anything worse.
- if (paint->numCoverageFragmentProcessors()) {
- return GrAAType::kCoverage;
- }
- // Shader based blending isn't so expensive with these extensions.
- if (caps.shaderCaps()->fbFetchSupport() || caps.textureBarrierSupport()) {
- return GrAAType::kCoverage;
- }
- SkBlendMode mode;
- if (GrXPFactory::AsBlendMode(paint->getXPFactory(), &mode)) {
- // If we have dual source blending then all Porter-Duff modes can use HW blending
- // with coverage.
- if (mode <= SkBlendMode::kLastCoeffMode &&
- caps.shaderCaps()->dualSourceBlendingSupport()) {
- return GrAAType::kCoverage;
- }
- if (SkBlendMode_SupportsCoverageAsAlpha(mode)) {
- return GrAAType::kCoverage;
- }
- // If the mode is "advanced" then either we will already be doing dst copies or we
- // have advanced blending support and it is ok to conflate coverage with alpha.
- if (mode > SkBlendMode::kLastCoeffMode) {
- return GrAAType::kCoverage;
- }
- }
- }
return GrAAType::kNone;
}
switch (fsaaType) {
@@ -944,16 +915,14 @@
AutoCheckFlush acf(this->drawingManager());
const SkStrokeRec stroke = style.strokeRec();
- GrAAType aaType = this->chooseAAType(aa, GrAllowMixedSamples::kNo,
- GrAllowNonAABinaryCoverage::kYes, &paint);
+ GrAAType aaType = this->chooseAAType(aa, GrAllowMixedSamples::kNo);
if (GrAAType::kCoverage == aaType) {
const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
- std::unique_ptr<GrDrawOp> op = GrOvalOpFactory::MakeCoverageRRectOp(std::move(paint),
- aa,
- viewMatrix,
- rrect,
- stroke,
- shaderCaps);
+ std::unique_ptr<GrDrawOp> op = GrOvalOpFactory::MakeRRectOp(std::move(paint),
+ viewMatrix,
+ rrect,
+ stroke,
+ shaderCaps);
if (op) {
this->addDrawOp(*clip, std::move(op));
return;
@@ -1217,9 +1186,8 @@
auto circleBounds = SkRect::MakeLTRB(cx - avgR, cy - avgR, cx + avgR, cy + avgR);
SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
stroke.setStrokeStyle(outerR - innerR);
- auto op = GrOvalOpFactory::MakeCoverageOvalOp(std::move(paint), aa, viewMatrix,
- circleBounds, stroke,
- this->caps()->shaderCaps());
+ auto op = GrOvalOpFactory::MakeOvalOp(std::move(paint), viewMatrix, circleBounds,
+ stroke, this->caps()->shaderCaps());
if (op) {
this->addDrawOp(clip, std::move(op));
return true;
@@ -1360,12 +1328,11 @@
AutoCheckFlush acf(this->drawingManager());
const SkStrokeRec& stroke = style.strokeRec();
- GrAAType aaType = this->chooseAAType(aa, GrAllowMixedSamples::kNo,
- GrAllowNonAABinaryCoverage::kYes, &paint);
+ GrAAType aaType = this->chooseAAType(aa, GrAllowMixedSamples::kNo);
if (GrAAType::kCoverage == aaType) {
const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
- std::unique_ptr<GrDrawOp> op = GrOvalOpFactory::MakeCoverageOvalOp(
- std::move(paint), aa, viewMatrix, oval, stroke, shaderCaps);
+ std::unique_ptr<GrDrawOp> op =
+ GrOvalOpFactory::MakeOvalOp(std::move(paint), viewMatrix, oval, stroke, shaderCaps);
if (op) {
this->addDrawOp(clip, std::move(op));
return;
@@ -1392,19 +1359,17 @@
AutoCheckFlush acf(this->drawingManager());
- GrAAType aaType = this->chooseAAType(aa, GrAllowMixedSamples::kNo,
- GrAllowNonAABinaryCoverage::kYes, &paint);
+ GrAAType aaType = this->chooseAAType(aa, GrAllowMixedSamples::kNo);
if (GrAAType::kCoverage == aaType) {
const GrShaderCaps* shaderCaps = fContext->caps()->shaderCaps();
- std::unique_ptr<GrDrawOp> op = GrOvalOpFactory::MakeCoverageArcOp(std::move(paint),
- aa,
- viewMatrix,
- oval,
- startAngle,
- sweepAngle,
- useCenter,
- style,
- shaderCaps);
+ std::unique_ptr<GrDrawOp> op = GrOvalOpFactory::MakeArcOp(std::move(paint),
+ viewMatrix,
+ oval,
+ startAngle,
+ sweepAngle,
+ useCenter,
+ style,
+ shaderCaps);
if (op) {
this->addDrawOp(clip, std::move(op));
return;
diff --git a/src/gpu/GrRenderTargetContext.h b/src/gpu/GrRenderTargetContext.h
index 9e4fb32..2ae52b9 100644
--- a/src/gpu/GrRenderTargetContext.h
+++ b/src/gpu/GrRenderTargetContext.h
@@ -386,12 +386,8 @@
private:
class TextTarget;
- GrAAType chooseAAType(
- GrAA aa, GrAllowMixedSamples allowMixedSamples,
- GrAllowNonAABinaryCoverage allowNonAABinaryCoverage = GrAllowNonAABinaryCoverage::kNo,
- const GrPaint* paint = nullptr) {
- return GrChooseAAType(aa, this->fsaaType(), allowMixedSamples, allowNonAABinaryCoverage,
- paint, *this->caps());
+ inline GrAAType chooseAAType(GrAA aa, GrAllowMixedSamples allowMixedSamples) {
+ return GrChooseAAType(aa, this->fsaaType(), allowMixedSamples, *this->caps());
}
friend class GrAtlasTextBlob; // for access to add[Mesh]DrawOp
diff --git a/src/gpu/GrXferProcessor.cpp b/src/gpu/GrXferProcessor.cpp
index 39bec98a..8f7377e 100644
--- a/src/gpu/GrXferProcessor.cpp
+++ b/src/gpu/GrXferProcessor.cpp
@@ -193,11 +193,3 @@
caps);
}
}
-
-bool GrXPFactory::AsBlendMode(const GrXPFactory* factory, SkBlendMode* mode) {
- if (factory) {
- return factory->asBlendMode(mode);
- }
- *mode = SkBlendMode::kSrcOver;
- return true;
-}
diff --git a/src/gpu/GrXferProcessor.h b/src/gpu/GrXferProcessor.h
index 3aac2d3..5ede1ae 100644
--- a/src/gpu/GrXferProcessor.h
+++ b/src/gpu/GrXferProcessor.h
@@ -301,9 +301,6 @@
const GrCaps&,
GrPixelConfigIsClamped);
- /** If true mode will be the equivalent SkBlendMode for the XPFactory. */
- static bool AsBlendMode(const GrXPFactory*, SkBlendMode* mode);
-
protected:
constexpr GrXPFactory() {}
@@ -322,8 +319,6 @@
const GrProcessorAnalysisCoverage&,
const GrCaps&,
GrPixelConfigIsClamped) const = 0;
-
- virtual bool asBlendMode(SkBlendMode*) const { return false; }
};
#if defined(__GNUC__)
#pragma GCC diagnostic pop
diff --git a/src/gpu/effects/GrCustomXfermode.cpp b/src/gpu/effects/GrCustomXfermode.cpp
index b43cea9..bdeda94 100644
--- a/src/gpu/effects/GrCustomXfermode.cpp
+++ b/src/gpu/effects/GrCustomXfermode.cpp
@@ -225,8 +225,6 @@
const GrCaps&,
GrPixelConfigIsClamped) const override;
- bool asBlendMode(SkBlendMode* mode) const override;
-
GR_DECLARE_XP_FACTORY_TEST
SkBlendMode fMode;
@@ -364,11 +362,6 @@
AnalysisProperties::kReadsDstInShader;
}
-bool CustomXPFactory::asBlendMode(SkBlendMode* mode) const {
- *mode = fMode;
- return true;
-}
-
GR_DEFINE_XP_FACTORY_TEST(CustomXPFactory);
#if GR_TEST_UTILS
const GrXPFactory* CustomXPFactory::TestGet(GrProcessorTestData* d) {
diff --git a/src/gpu/effects/GrPorterDuffXferProcessor.cpp b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
index c8f11e0..f4af7a4 100644
--- a/src/gpu/effects/GrPorterDuffXferProcessor.cpp
+++ b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
@@ -861,11 +861,6 @@
return analysis_properties(color, coverage, caps, dstIsClamped, fBlendMode);
}
-bool GrPorterDuffXPFactory::asBlendMode(SkBlendMode* mode) const {
- *mode = fBlendMode;
- return true;
-}
-
GR_DEFINE_XP_FACTORY_TEST(GrPorterDuffXPFactory);
#if GR_TEST_UTILS
diff --git a/src/gpu/effects/GrPorterDuffXferProcessor.h b/src/gpu/effects/GrPorterDuffXferProcessor.h
index 8241a9f..74ae153 100644
--- a/src/gpu/effects/GrPorterDuffXferProcessor.h
+++ b/src/gpu/effects/GrPorterDuffXferProcessor.h
@@ -58,8 +58,6 @@
const GrCaps&,
GrPixelConfigIsClamped) const override;
- bool asBlendMode(SkBlendMode* mode) const override;
-
GR_DECLARE_XP_FACTORY_TEST
static void TestGetXPOutputTypes(const GrXferProcessor*, int* outPrimary, int* outSecondary);
diff --git a/src/gpu/ops/GrOvalOpFactory.cpp b/src/gpu/ops/GrOvalOpFactory.cpp
index e5f1abf..9194f67 100644
--- a/src/gpu/ops/GrOvalOpFactory.cpp
+++ b/src/gpu/ops/GrOvalOpFactory.cpp
@@ -66,12 +66,10 @@
class CircleGeometryProcessor : public GrGeometryProcessor {
public:
- CircleGeometryProcessor(bool stroke, bool clipPlane, bool isectPlane, bool unionPlane, GrAA aa,
+ CircleGeometryProcessor(bool stroke, bool clipPlane, bool isectPlane, bool unionPlane,
const SkMatrix& localMatrix)
: INHERITED(kCircleGeometryProcessor_ClassID)
- , fLocalMatrix(localMatrix)
- , fStroke(stroke)
- , fAA(aa) {
+ , fLocalMatrix(localMatrix) {
fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType);
fInCircleEdge = &this->addVertexAttrib("inCircleEdge", kFloat4_GrVertexAttribType);
@@ -90,6 +88,7 @@
} else {
fInUnionPlane = nullptr;
}
+ fStroke = stroke;
}
~CircleGeometryProcessor() override {}
@@ -175,16 +174,7 @@
}
fragBuilder->codeAppend("edgeAlpha *= clip;");
}
- if (GrAA::kYes == cgp.fAA) {
- fragBuilder->codeAppendf("%s = half4(edgeAlpha);", args.fOutputCoverage);
- } else {
- // Using a value less than half is a bit of a hack. If 0.5 is used then filling
- // a set of abutting arcs that should create a full circle can leave gaps at pixels
- // that neither arc quite owns. Generally speaking, double hitting these pixels
- // instead of missing them looks better.
- fragBuilder->codeAppendf("%s = edgeAlpha > 0.4999 ? half4(1) : half4(0);",
- args.fOutputCoverage);
- }
+ fragBuilder->codeAppendf("%s = half4(edgeAlpha);", args.fOutputCoverage);
}
static void GenKey(const GrGeometryProcessor& gp,
@@ -197,7 +187,6 @@
key |= cgp.fInClipPlane ? 0x04 : 0x0;
key |= cgp.fInIsectPlane ? 0x08 : 0x0;
key |= cgp.fInUnionPlane ? 0x10 : 0x0;
- key |= GrAA::kYes == cgp.fAA ? 0x20 : 0x0;
b->add32(key);
}
@@ -219,7 +208,6 @@
const Attribute* fInIsectPlane;
const Attribute* fInUnionPlane;
bool fStroke;
- GrAA fAA;
GR_DECLARE_GEOMETRY_PROCESSOR_TEST
@@ -230,10 +218,9 @@
#if GR_TEST_UTILS
sk_sp<GrGeometryProcessor> CircleGeometryProcessor::TestCreate(GrProcessorTestData* d) {
- GrAA aa = d->fRandom->nextBool() ? GrAA::kYes : GrAA::kNo;
return sk_sp<GrGeometryProcessor>(new CircleGeometryProcessor(
d->fRandom->nextBool(), d->fRandom->nextBool(), d->fRandom->nextBool(),
- d->fRandom->nextBool(), aa, GrTest::TestMatrix(d->fRandom)));
+ d->fRandom->nextBool(), GrTest::TestMatrix(d->fRandom)));
}
#endif
@@ -249,15 +236,14 @@
class EllipseGeometryProcessor : public GrGeometryProcessor {
public:
- EllipseGeometryProcessor(bool stroke, GrAA aa, const SkMatrix& localMatrix)
- : INHERITED(kEllipseGeometryProcessor_ClassID)
- , fLocalMatrix(localMatrix)
- , fStroke(stroke)
- , fAA(aa) {
+ EllipseGeometryProcessor(bool stroke, const SkMatrix& localMatrix)
+ : INHERITED(kEllipseGeometryProcessor_ClassID)
+ , fLocalMatrix(localMatrix) {
fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType);
fInEllipseOffset = &this->addVertexAttrib("inEllipseOffset", kHalf2_GrVertexAttribType);
fInEllipseRadii = &this->addVertexAttrib("inEllipseRadii", kHalf4_GrVertexAttribType);
+ fStroke = stroke;
}
~EllipseGeometryProcessor() override {}
@@ -332,12 +318,7 @@
fragBuilder->codeAppend("edgeAlpha *= clamp(0.5+test*invlen, 0.0, 1.0);");
}
- if (GrAA::kYes == egp.fAA) {
- fragBuilder->codeAppendf("%s = half4(edgeAlpha);", args.fOutputCoverage);
- } else {
- fragBuilder->codeAppendf("%s = edgeAlpha > 0.5 ? half4(1) : half4(0);",
- args.fOutputCoverage);
- }
+ fragBuilder->codeAppendf("%s = half4(edgeAlpha);", args.fOutputCoverage);
}
static void GenKey(const GrGeometryProcessor& gp,
@@ -346,7 +327,6 @@
const EllipseGeometryProcessor& egp = gp.cast<EllipseGeometryProcessor>();
uint16_t key = egp.fStroke ? 0x1 : 0x0;
key |= egp.fLocalMatrix.hasPerspective() ? 0x2 : 0x0;
- key |= GrAA::kYes == egp.fAA ? 0x4 : 0x0;
b->add32(key);
}
@@ -366,7 +346,6 @@
const Attribute* fInEllipseRadii;
SkMatrix fLocalMatrix;
bool fStroke;
- GrAA fAA;
GR_DECLARE_GEOMETRY_PROCESSOR_TEST
@@ -377,9 +356,8 @@
#if GR_TEST_UTILS
sk_sp<GrGeometryProcessor> EllipseGeometryProcessor::TestCreate(GrProcessorTestData* d) {
- GrAA aa = d->fRandom->nextBool() ? GrAA::kYes : GrAA::kNo;
- return sk_sp<GrGeometryProcessor>(new EllipseGeometryProcessor(d->fRandom->nextBool(), aa,
- GrTest::TestMatrix(d->fRandom)));
+ return sk_sp<GrGeometryProcessor>(
+ new EllipseGeometryProcessor(d->fRandom->nextBool(), GrTest::TestMatrix(d->fRandom)));
}
#endif
@@ -398,15 +376,14 @@
class DIEllipseGeometryProcessor : public GrGeometryProcessor {
public:
- DIEllipseGeometryProcessor(const SkMatrix& viewMatrix, DIEllipseStyle style, GrAA aa)
+ DIEllipseGeometryProcessor(const SkMatrix& viewMatrix, DIEllipseStyle style)
: INHERITED(kDIEllipseGeometryProcessor_ClassID)
- , fViewMatrix(viewMatrix)
- , fStyle(style)
- , fAA(aa) {
+ , fViewMatrix(viewMatrix) {
fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType);
fInEllipseOffsets0 = &this->addVertexAttrib("inEllipseOffsets0", kHalf2_GrVertexAttribType);
fInEllipseOffsets1 = &this->addVertexAttrib("inEllipseOffsets1", kHalf2_GrVertexAttribType);
+ fStyle = style;
}
~DIEllipseGeometryProcessor() override {}
@@ -496,12 +473,8 @@
fragBuilder->codeAppend("invlen = inversesqrt(dot(grad, grad));");
fragBuilder->codeAppend("edgeAlpha *= clamp(0.5+test*invlen, 0.0, 1.0);");
}
- if (GrAA::kYes == diegp.fAA) {
- fragBuilder->codeAppendf("%s = half4(edgeAlpha);", args.fOutputCoverage);
- } else {
- fragBuilder->codeAppendf("%s = edgeAlpha > 0.5 ? half4(1) : half4(0);",
- args.fOutputCoverage);
- }
+
+ fragBuilder->codeAppendf("%s = half4(edgeAlpha);", args.fOutputCoverage);
}
static void GenKey(const GrGeometryProcessor& gp,
@@ -509,7 +482,6 @@
GrProcessorKeyBuilder* b) {
const DIEllipseGeometryProcessor& diegp = gp.cast<DIEllipseGeometryProcessor>();
uint16_t key = static_cast<uint16_t>(diegp.fStyle);
- key |= GrAA::kYes == diegp.fAA ? 0x80 : 0x0;
key |= ComputePosKey(diegp.fViewMatrix) << 10;
b->add32(key);
}
@@ -540,7 +512,6 @@
const Attribute* fInEllipseOffsets1;
SkMatrix fViewMatrix;
DIEllipseStyle fStyle;
- GrAA fAA;
GR_DECLARE_GEOMETRY_PROCESSOR_TEST
@@ -551,9 +522,8 @@
#if GR_TEST_UTILS
sk_sp<GrGeometryProcessor> DIEllipseGeometryProcessor::TestCreate(GrProcessorTestData* d) {
- GrAA aa = d->fRandom->nextBool() ? GrAA::kYes : GrAA::kNo;
return sk_sp<GrGeometryProcessor>(new DIEllipseGeometryProcessor(
- GrTest::TestMatrix(d->fRandom), (DIEllipseStyle)(d->fRandom->nextRangeU(0, 2)), aa));
+ GrTest::TestMatrix(d->fRandom), (DIEllipseStyle)(d->fRandom->nextRangeU(0, 2))));
}
#endif
@@ -621,7 +591,7 @@
bool fUseCenter;
};
- static std::unique_ptr<GrDrawOp> Make(GrPaint&& paint, GrAA aa, const SkMatrix& viewMatrix,
+ static std::unique_ptr<GrDrawOp> Make(GrPaint&& paint, const SkMatrix& viewMatrix,
SkPoint center, SkScalar radius, const GrStyle& style,
const ArcParams* arcParams = nullptr) {
SkASSERT(circle_stays_circle(viewMatrix));
@@ -648,13 +618,13 @@
break;
}
}
- return Helper::FactoryHelper<CircleOp>(std::move(paint), aa, viewMatrix, center, radius,
- style, arcParams);
+ return Helper::FactoryHelper<CircleOp>(std::move(paint), viewMatrix, center, radius, style,
+ arcParams);
}
- CircleOp(const Helper::MakeArgs& helperArgs, GrColor color, GrAA aa, const SkMatrix& viewMatrix,
+ CircleOp(const Helper::MakeArgs& helperArgs, GrColor color, const SkMatrix& viewMatrix,
SkPoint center, SkScalar radius, const GrStyle& style, const ArcParams* arcParams)
- : GrMeshDrawOp(ClassID()), fHelper(helperArgs, GrAAType::kCoverage), fAA(aa) {
+ : GrMeshDrawOp(ClassID()), fHelper(helperArgs, GrAAType::kCoverage) {
const SkStrokeRec& stroke = style.strokeRec();
SkStrokeRec::Style recStyle = stroke.getStyle();
@@ -846,7 +816,7 @@
// Setup geometry processor
sk_sp<GrGeometryProcessor> gp(new CircleGeometryProcessor(
- !fAllFill, fClipPlane, fClipPlaneIsect, fClipPlaneUnion, fAA, localMatrix));
+ !fAllFill, fClipPlane, fClipPlaneIsect, fClipPlaneUnion, localMatrix));
struct CircleVertex {
SkPoint fPos;
@@ -1135,10 +1105,6 @@
return false;
}
- if (fAA != that->fAA) {
- return false;
- }
-
// Because we've set up the ops that don't use the planes with noop values
// we can just accumulate used planes by later ops.
fClipPlane |= that->fClipPlane;
@@ -1173,7 +1139,6 @@
bool fClipPlane;
bool fClipPlaneIsect;
bool fClipPlaneUnion;
- GrAA fAA;
typedef GrMeshDrawOp INHERITED;
};
@@ -1195,7 +1160,7 @@
public:
DEFINE_OP_CLASS_ID
- static std::unique_ptr<GrDrawOp> Make(GrPaint&& paint, GrAA aa, const SkMatrix& viewMatrix,
+ static std::unique_ptr<GrDrawOp> Make(GrPaint&& paint, const SkMatrix& viewMatrix,
const SkRect& ellipse, const SkStrokeRec& stroke) {
DeviceSpaceParams params;
// do any matrix crunching before we reset the draw state for device coords
@@ -1254,13 +1219,12 @@
params.fXRadius += scaledStroke.fX;
params.fYRadius += scaledStroke.fY;
}
- return Helper::FactoryHelper<EllipseOp>(std::move(paint), aa, viewMatrix, params, stroke);
+ return Helper::FactoryHelper<EllipseOp>(std::move(paint), viewMatrix, params, stroke);
}
- EllipseOp(const Helper::MakeArgs& helperArgs, GrColor color, GrAA aa,
- const SkMatrix& viewMatrix, const DeviceSpaceParams& params,
- const SkStrokeRec& stroke)
- : INHERITED(ClassID()), fHelper(helperArgs, GrAAType::kCoverage), fAA(aa) {
+ EllipseOp(const Helper::MakeArgs& helperArgs, GrColor color, const SkMatrix& viewMatrix,
+ const DeviceSpaceParams& params, const SkStrokeRec& stroke)
+ : INHERITED(ClassID()), fHelper(helperArgs, GrAAType::kCoverage) {
SkStrokeRec::Style style = stroke.getStyle();
bool isStrokeOnly =
SkStrokeRec::kStroke_Style == style || SkStrokeRec::kHairline_Style == style;
@@ -1320,7 +1284,7 @@
}
// Setup geometry processor
- sk_sp<GrGeometryProcessor> gp(new EllipseGeometryProcessor(fStroked, fAA, localMatrix));
+ sk_sp<GrGeometryProcessor> gp(new EllipseGeometryProcessor(fStroked, localMatrix));
QuadHelper helper;
size_t vertexStride = gp->getVertexStride();
@@ -1392,10 +1356,6 @@
return false;
}
- if (fAA != that->fAA) {
- return false;
- }
-
fEllipses.push_back_n(that->fEllipses.count(), that->fEllipses.begin());
this->joinBounds(*that);
return true;
@@ -1413,7 +1373,6 @@
SkMatrix fViewMatrixIfUsingLocalCoords;
Helper fHelper;
bool fStroked;
- GrAA fAA;
SkSTArray<1, Ellipse, true> fEllipses;
typedef GrMeshDrawOp INHERITED;
@@ -1437,7 +1396,7 @@
public:
DEFINE_OP_CLASS_ID
- static std::unique_ptr<GrDrawOp> Make(GrPaint&& paint, GrAA aa, const SkMatrix& viewMatrix,
+ static std::unique_ptr<GrDrawOp> Make(GrPaint&& paint, const SkMatrix& viewMatrix,
const SkRect& ellipse, const SkStrokeRec& stroke) {
DeviceSpaceParams params;
params.fCenter = SkPoint::Make(ellipse.centerX(), ellipse.centerY());
@@ -1492,12 +1451,12 @@
(params.fInnerXRadius <= 0 || params.fInnerYRadius <= 0)) {
params.fStyle = DIEllipseStyle::kFill;
}
- return Helper::FactoryHelper<DIEllipseOp>(std::move(paint), aa, params, viewMatrix);
+ return Helper::FactoryHelper<DIEllipseOp>(std::move(paint), params, viewMatrix);
}
- DIEllipseOp(Helper::MakeArgs& helperArgs, GrColor color, GrAA aa,
- const DeviceSpaceParams& params, const SkMatrix& viewMatrix)
- : INHERITED(ClassID()), fHelper(helperArgs, GrAAType::kCoverage), fAA(aa) {
+ DIEllipseOp(Helper::MakeArgs& helperArgs, GrColor color, const DeviceSpaceParams& params,
+ const SkMatrix& viewMatrix)
+ : INHERITED(ClassID()), fHelper(helperArgs, GrAAType::kCoverage) {
// This expands the outer rect so that after CTM we end up with a half-pixel border
SkScalar a = viewMatrix[SkMatrix::kMScaleX];
SkScalar b = viewMatrix[SkMatrix::kMSkewX];
@@ -1552,7 +1511,7 @@
void onPrepareDraws(Target* target) override {
// Setup geometry processor
sk_sp<GrGeometryProcessor> gp(
- new DIEllipseGeometryProcessor(this->viewMatrix(), this->style(), fAA));
+ new DIEllipseGeometryProcessor(this->viewMatrix(), this->style()));
size_t vertexStride = gp->getVertexStride();
SkASSERT(vertexStride == sizeof(DIEllipseVertex));
@@ -1617,10 +1576,6 @@
return false;
}
- if (fAA != that->fAA) {
- return false;
- }
-
fEllipses.push_back_n(that->fEllipses.count(), that->fEllipses.begin());
this->joinBounds(*that);
return true;
@@ -1644,7 +1599,6 @@
Helper fHelper;
SkSTArray<1, Ellipse, true> fEllipses;
- GrAA fAA;
typedef GrMeshDrawOp INHERITED;
};
@@ -1784,19 +1738,17 @@
// A devStrokeWidth <= 0 indicates a fill only. If devStrokeWidth > 0 then strokeOnly indicates
// whether the rrect is only stroked or stroked and filled.
- static std::unique_ptr<GrDrawOp> Make(GrPaint&& paint, GrAA aa, const SkMatrix& viewMatrix,
+ static std::unique_ptr<GrDrawOp> Make(GrPaint&& paint, const SkMatrix& viewMatrix,
const SkRect& devRect, float devRadius,
float devStrokeWidth, bool strokeOnly) {
- return Helper::FactoryHelper<CircularRRectOp>(std::move(paint), aa, viewMatrix, devRect,
+ return Helper::FactoryHelper<CircularRRectOp>(std::move(paint), viewMatrix, devRect,
devRadius, devStrokeWidth, strokeOnly);
}
- CircularRRectOp(Helper::MakeArgs& helperArgs, GrColor color, GrAA aa,
- const SkMatrix& viewMatrix, const SkRect& devRect, float devRadius,
- float devStrokeWidth, bool strokeOnly)
+ CircularRRectOp(Helper::MakeArgs& helperArgs, GrColor color, const SkMatrix& viewMatrix,
+ const SkRect& devRect, float devRadius, float devStrokeWidth, bool strokeOnly)
: INHERITED(ClassID())
, fViewMatrixIfUsingLocalCoords(viewMatrix)
- , fHelper(helperArgs, GrAAType::kCoverage)
- , fAA(aa) {
+ , fHelper(helperArgs, GrAAType::kCoverage) {
SkRect bounds = devRect;
SkASSERT(!(devStrokeWidth <= 0 && strokeOnly));
SkScalar innerRadius = 0.0f;
@@ -1958,7 +1910,7 @@
// Setup geometry processor
sk_sp<GrGeometryProcessor> gp(
- new CircleGeometryProcessor(!fAllFill, false, false, false, fAA, localMatrix));
+ new CircleGeometryProcessor(!fAllFill, false, false, false, localMatrix));
size_t vertexStride = gp->getVertexStride();
SkASSERT(sizeof(CircleVertex) == vertexStride);
@@ -2077,10 +2029,6 @@
return false;
}
- if (fAA != that->fAA) {
- return false;
- }
-
fRRects.push_back_n(that->fRRects.count(), that->fRRects.begin());
this->joinBounds(*that);
fVertCount += that->fVertCount;
@@ -2102,7 +2050,6 @@
int fVertCount;
int fIndexCount;
bool fAllFill;
- GrAA fAA;
SkSTArray<1, RRect, true> fRRects;
typedef GrMeshDrawOp INHERITED;
@@ -2140,7 +2087,7 @@
// If devStrokeWidths values are <= 0 indicates then fill only. Otherwise, strokeOnly indicates
// whether the rrect is only stroked or stroked and filled.
- static std::unique_ptr<GrDrawOp> Make(GrPaint&& paint, GrAA aa, const SkMatrix& viewMatrix,
+ static std::unique_ptr<GrDrawOp> Make(GrPaint&& paint, const SkMatrix& viewMatrix,
const SkRect& devRect, float devXRadius, float devYRadius,
SkVector devStrokeWidths, bool strokeOnly) {
SkASSERT(devXRadius > 0.5);
@@ -2171,15 +2118,15 @@
return nullptr;
}
}
- return Helper::FactoryHelper<EllipticalRRectOp>(std::move(paint), aa, viewMatrix, devRect,
+ return Helper::FactoryHelper<EllipticalRRectOp>(std::move(paint), viewMatrix, devRect,
devXRadius, devYRadius, devStrokeWidths,
strokeOnly);
}
- EllipticalRRectOp(Helper::MakeArgs helperArgs, GrColor color, GrAA aa,
- const SkMatrix& viewMatrix, const SkRect& devRect, float devXRadius,
- float devYRadius, SkVector devStrokeHalfWidths, bool strokeOnly)
- : INHERITED(ClassID()), fHelper(helperArgs, GrAAType::kCoverage), fAA(aa) {
+ EllipticalRRectOp(Helper::MakeArgs helperArgs, GrColor color, const SkMatrix& viewMatrix,
+ const SkRect& devRect, float devXRadius, float devYRadius,
+ SkVector devStrokeHalfWidths, bool strokeOnly)
+ : INHERITED(ClassID()), fHelper(helperArgs, GrAAType::kCoverage) {
SkScalar innerXRadius = 0.0f;
SkScalar innerYRadius = 0.0f;
SkRect bounds = devRect;
@@ -2245,7 +2192,7 @@
}
// Setup geometry processor
- sk_sp<GrGeometryProcessor> gp(new EllipseGeometryProcessor(fStroked, fAA, localMatrix));
+ sk_sp<GrGeometryProcessor> gp(new EllipseGeometryProcessor(fStroked, localMatrix));
size_t vertexStride = gp->getVertexStride();
SkASSERT(vertexStride == sizeof(EllipseVertex));
@@ -2333,9 +2280,7 @@
!fViewMatrixIfUsingLocalCoords.cheapEqualTo(that->fViewMatrixIfUsingLocalCoords)) {
return false;
}
- if (fAA != that->fAA) {
- return false;
- }
+
fRRects.push_back_n(that->fRRects.count(), that->fRRects.begin());
this->joinBounds(*that);
return true;
@@ -2353,14 +2298,12 @@
SkMatrix fViewMatrixIfUsingLocalCoords;
Helper fHelper;
bool fStroked;
- GrAA fAA;
SkSTArray<1, RRect, true> fRRects;
typedef GrMeshDrawOp INHERITED;
};
static std::unique_ptr<GrDrawOp> make_rrect_op(GrPaint&& paint,
- GrAA aa,
const SkMatrix& viewMatrix,
const SkRRect& rrect,
const SkStrokeRec& stroke) {
@@ -2421,58 +2364,55 @@
// if the corners are circles, use the circle renderer
if (isCircular) {
- return CircularRRectOp::Make(std::move(paint), aa, viewMatrix, bounds, xRadius,
- scaledStroke.fX, isStrokeOnly);
+ return CircularRRectOp::Make(std::move(paint), viewMatrix, bounds, xRadius, scaledStroke.fX,
+ isStrokeOnly);
// otherwise we use the ellipse renderer
} else {
- return EllipticalRRectOp::Make(std::move(paint), aa, viewMatrix, bounds, xRadius, yRadius,
+ return EllipticalRRectOp::Make(std::move(paint), viewMatrix, bounds, xRadius, yRadius,
scaledStroke, isStrokeOnly);
}
}
-std::unique_ptr<GrDrawOp> GrOvalOpFactory::MakeCoverageRRectOp(GrPaint&& paint,
- GrAA aa,
- const SkMatrix& viewMatrix,
- const SkRRect& rrect,
- const SkStrokeRec& stroke,
- const GrShaderCaps* shaderCaps) {
+std::unique_ptr<GrDrawOp> GrOvalOpFactory::MakeRRectOp(GrPaint&& paint,
+ const SkMatrix& viewMatrix,
+ const SkRRect& rrect,
+ const SkStrokeRec& stroke,
+ const GrShaderCaps* shaderCaps) {
if (rrect.isOval()) {
- return MakeCoverageOvalOp(std::move(paint), aa, viewMatrix, rrect.getBounds(), stroke,
- shaderCaps);
+ return MakeOvalOp(std::move(paint), viewMatrix, rrect.getBounds(), stroke, shaderCaps);
}
if (!viewMatrix.rectStaysRect() || !rrect.isSimple()) {
return nullptr;
}
- return make_rrect_op(std::move(paint), aa, viewMatrix, rrect, stroke);
+ return make_rrect_op(std::move(paint), viewMatrix, rrect, stroke);
}
///////////////////////////////////////////////////////////////////////////////
-std::unique_ptr<GrDrawOp> GrOvalOpFactory::MakeCoverageOvalOp(GrPaint&& paint,
- GrAA aa,
- const SkMatrix& viewMatrix,
- const SkRect& oval,
- const SkStrokeRec& stroke,
- const GrShaderCaps* shaderCaps) {
+std::unique_ptr<GrDrawOp> GrOvalOpFactory::MakeOvalOp(GrPaint&& paint,
+ const SkMatrix& viewMatrix,
+ const SkRect& oval,
+ const SkStrokeRec& stroke,
+ const GrShaderCaps* shaderCaps) {
// we can draw circles
SkScalar width = oval.width();
if (width > SK_ScalarNearlyZero && SkScalarNearlyEqual(width, oval.height()) &&
circle_stays_circle(viewMatrix)) {
SkPoint center = {oval.centerX(), oval.centerY()};
- return CircleOp::Make(std::move(paint), aa, viewMatrix, center, width / 2.f,
+ return CircleOp::Make(std::move(paint), viewMatrix, center, width / 2.f,
GrStyle(stroke, nullptr));
}
// prefer the device space ellipse op for batchability
if (viewMatrix.rectStaysRect()) {
- return EllipseOp::Make(std::move(paint), aa, viewMatrix, oval, stroke);
+ return EllipseOp::Make(std::move(paint), viewMatrix, oval, stroke);
}
// Otherwise, if we have shader derivative support, render as device-independent
if (shaderCaps->shaderDerivativeSupport()) {
- return DIEllipseOp::Make(std::move(paint), aa, viewMatrix, oval, stroke);
+ return DIEllipseOp::Make(std::move(paint), viewMatrix, oval, stroke);
}
return nullptr;
@@ -2480,10 +2420,11 @@
///////////////////////////////////////////////////////////////////////////////
-std::unique_ptr<GrDrawOp> GrOvalOpFactory::MakeCoverageArcOp(
- GrPaint&& paint, GrAA aa, const SkMatrix& viewMatrix, const SkRect& oval,
- SkScalar startAngle, SkScalar sweepAngle, bool useCenter, const GrStyle& style,
- const GrShaderCaps* shaderCaps) {
+std::unique_ptr<GrDrawOp> GrOvalOpFactory::MakeArcOp(GrPaint&& paint, const SkMatrix& viewMatrix,
+ const SkRect& oval, SkScalar startAngle,
+ SkScalar sweepAngle, bool useCenter,
+ const GrStyle& style,
+ const GrShaderCaps* shaderCaps) {
SkASSERT(!oval.isEmpty());
SkASSERT(sweepAngle);
SkScalar width = oval.width();
@@ -2496,7 +2437,7 @@
SkPoint center = {oval.centerX(), oval.centerY()};
CircleOp::ArcParams arcParams = {SkDegreesToRadians(startAngle), SkDegreesToRadians(sweepAngle),
useCenter};
- return CircleOp::Make(std::move(paint), aa, viewMatrix, center, width / 2.f, style, &arcParams);
+ return CircleOp::Make(std::move(paint), viewMatrix, center, width / 2.f, style, &arcParams);
}
///////////////////////////////////////////////////////////////////////////////
@@ -2519,15 +2460,14 @@
SkStrokeRec stroke = GrTest::TestStrokeRec(random);
CircleOp::ArcParams arcParamsTmp;
const CircleOp::ArcParams* arcParams = nullptr;
- GrAA aa = random->nextBool() ? GrAA::kYes : GrAA::kNo;
if (random->nextBool()) {
arcParamsTmp.fStartAngleRadians = random->nextSScalar1() * SK_ScalarPI * 2;
arcParamsTmp.fSweepAngleRadians = random->nextSScalar1() * SK_ScalarPI * 2 - .01f;
arcParamsTmp.fUseCenter = random->nextBool();
arcParams = &arcParamsTmp;
}
- std::unique_ptr<GrDrawOp> op = CircleOp::Make(std::move(paint), aa, viewMatrix, center,
- radius, GrStyle(stroke, nullptr), arcParams);
+ std::unique_ptr<GrDrawOp> op = CircleOp::Make(std::move(paint), viewMatrix, center, radius,
+ GrStyle(stroke, nullptr), arcParams);
if (op) {
return op;
}
@@ -2537,24 +2477,19 @@
GR_DRAW_OP_TEST_DEFINE(EllipseOp) {
SkMatrix viewMatrix = GrTest::TestMatrixRectStaysRect(random);
SkRect ellipse = GrTest::TestSquare(random);
- GrAA aa = random->nextBool() ? GrAA::kYes : GrAA::kNo;
- return EllipseOp::Make(std::move(paint), aa, viewMatrix, ellipse,
- GrTest::TestStrokeRec(random));
+ return EllipseOp::Make(std::move(paint), viewMatrix, ellipse, GrTest::TestStrokeRec(random));
}
GR_DRAW_OP_TEST_DEFINE(DIEllipseOp) {
SkMatrix viewMatrix = GrTest::TestMatrix(random);
SkRect ellipse = GrTest::TestSquare(random);
- GrAA aa = random->nextBool() ? GrAA::kYes : GrAA::kNo;
- return DIEllipseOp::Make(std::move(paint), aa, viewMatrix, ellipse,
- GrTest::TestStrokeRec(random));
+ return DIEllipseOp::Make(std::move(paint), viewMatrix, ellipse, GrTest::TestStrokeRec(random));
}
GR_DRAW_OP_TEST_DEFINE(RRectOp) {
SkMatrix viewMatrix = GrTest::TestMatrixRectStaysRect(random);
const SkRRect& rrect = GrTest::TestRRectSimple(random);
- GrAA aa = random->nextBool() ? GrAA::kYes : GrAA::kNo;
- return make_rrect_op(std::move(paint), aa, viewMatrix, rrect, GrTest::TestStrokeRec(random));
+ return make_rrect_op(std::move(paint), viewMatrix, rrect, GrTest::TestStrokeRec(random));
}
#endif
diff --git a/src/gpu/ops/GrOvalOpFactory.h b/src/gpu/ops/GrOvalOpFactory.h
index d31e09e..1bdf3ee 100644
--- a/src/gpu/ops/GrOvalOpFactory.h
+++ b/src/gpu/ops/GrOvalOpFactory.h
@@ -22,33 +22,29 @@
/*
* This namespace wraps helper functions that draw ovals, rrects, and arcs (filled & stroked)
- * The ops always use coverage even when their non-AA.
*/
class GrOvalOpFactory {
public:
- static std::unique_ptr<GrDrawOp> MakeCoverageOvalOp(GrPaint&&,
- GrAA,
- const SkMatrix&,
- const SkRect& oval,
- const SkStrokeRec&,
- const GrShaderCaps*);
+ static std::unique_ptr<GrDrawOp> MakeOvalOp(GrPaint&&,
+ const SkMatrix&,
+ const SkRect& oval,
+ const SkStrokeRec&,
+ const GrShaderCaps*);
- static std::unique_ptr<GrDrawOp> MakeCoverageRRectOp(GrPaint&&,
- GrAA,
- const SkMatrix&,
- const SkRRect&,
- const SkStrokeRec&,
- const GrShaderCaps*);
+ static std::unique_ptr<GrDrawOp> MakeRRectOp(GrPaint&&,
+ const SkMatrix&,
+ const SkRRect&,
+ const SkStrokeRec&,
+ const GrShaderCaps*);
- static std::unique_ptr<GrDrawOp> MakeCoverageArcOp(GrPaint&&,
- GrAA,
- const SkMatrix&,
- const SkRect& oval,
- SkScalar startAngle,
- SkScalar sweepAngle,
- bool useCenter,
- const GrStyle&,
- const GrShaderCaps*);
+ static std::unique_ptr<GrDrawOp> MakeArcOp(GrPaint&&,
+ const SkMatrix&,
+ const SkRect& oval,
+ SkScalar startAngle,
+ SkScalar sweepAngle,
+ bool useCenter,
+ const GrStyle&,
+ const GrShaderCaps*);
};
#endif // GrOvalOpFactory_DEFINED
diff --git a/src/gpu/text/GrStencilAndCoverTextContext.cpp b/src/gpu/text/GrStencilAndCoverTextContext.cpp
index 951b1df..86e5732 100644
--- a/src/gpu/text/GrStencilAndCoverTextContext.cpp
+++ b/src/gpu/text/GrStencilAndCoverTextContext.cpp
@@ -583,8 +583,7 @@
// The run's "font" overrides the anti-aliasing of the passed in SkPaint!
GrAAType aaType = GrChooseAAType(this->aa(), renderTargetContext->fsaaType(),
- GrAllowMixedSamples::kYes, GrAllowNonAABinaryCoverage::kNo,
- nullptr, *renderTargetContext->caps());
+ GrAllowMixedSamples::kYes, *renderTargetContext->caps());
std::unique_ptr<GrDrawOp> op = GrDrawPathRangeOp::Make(
viewMatrix, fTextRatio, fTextInverseRatio * x, fTextInverseRatio * y,
