Eliminate mixed samples as an FBO type or AA type
From now on, sample counts always refer to the number of actual color
samples, and render targets don't have separate color and stencil
sample counts.
If mixed samples support is available when making a
"GrAAType::kCoverage" draw, then an op may attach and use a mixed
sampled stencil buffer internally. But this will all be invisible to
the client.
After this CL, we temporarily won't have a mode to use nvpr with mixed
samples. That will soon be fixed by a follow-on CL that enables nvpr
with mixed samples in the normal "gl" and "gles" configs.
Bug: skia:
Change-Id: I1cb8277f0d2d0d371f24bb9f39cd473ed5c5c83b
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/221878
Commit-Queue: Chris Dalton <csmartdalton@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
diff --git a/src/gpu/ops/GrAAConvexPathRenderer.cpp b/src/gpu/ops/GrAAConvexPathRenderer.cpp
index 85ea734..5944aef 100644
--- a/src/gpu/ops/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAAConvexPathRenderer.cpp
@@ -654,7 +654,7 @@
GrPathRenderer::CanDrawPath
GrAAConvexPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
if (args.fCaps->shaderCaps()->shaderDerivativeSupport() &&
- (AATypeFlags::kCoverage & args.fAATypeFlags) && args.fShape->style().isSimpleFill() &&
+ (GrAAType::kCoverage == args.fAAType) && args.fShape->style().isSimpleFill() &&
!args.fShape->inverseFilled() && args.fShape->knownToBeConvex()) {
return CanDrawPath::kYes;
}
@@ -705,11 +705,12 @@
FixedFunctionFlags fixedFunctionFlags() const override { return fHelper.fixedFunctionFlags(); }
- GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) override {
+ GrProcessorSet::Analysis finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) override {
return fHelper.finalizeProcessors(
- caps, clip, fsaaType, clampType, GrProcessorAnalysisCoverage::kSingleChannel,
- &fPaths.back().fColor, &fWideColor);
+ caps, clip, hasMixedSampledCoverage, clampType,
+ GrProcessorAnalysisCoverage::kSingleChannel, &fPaths.back().fColor, &fWideColor);
}
private:
@@ -835,7 +836,7 @@
bool GrAAConvexPathRenderer::onDrawPath(const DrawPathArgs& args) {
GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(),
"GrAAConvexPathRenderer::onDrawPath");
- SkASSERT(GrFSAAType::kUnifiedMSAA != args.fRenderTargetContext->fsaaType());
+ SkASSERT(args.fRenderTargetContext->numSamples() <= 1);
SkASSERT(!args.fShape->isEmpty());
SkPath path;
diff --git a/src/gpu/ops/GrAAHairLinePathRenderer.cpp b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
index 1aa1638..6b054f8 100644
--- a/src/gpu/ops/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
@@ -714,7 +714,7 @@
GrPathRenderer::CanDrawPath
GrAAHairLinePathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
- if (!(AATypeFlags::kCoverage & args.fAATypeFlags)) {
+ if (GrAAType::kCoverage != args.fAAType) {
return CanDrawPath::kNo;
}
@@ -839,10 +839,11 @@
FixedFunctionFlags fixedFunctionFlags() const override { return fHelper.fixedFunctionFlags(); }
- GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) override {
+ GrProcessorSet::Analysis finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) override {
// This Op uses uniform (not vertex) color, so doesn't need to track wide color.
- return fHelper.finalizeProcessors(caps, clip, fsaaType, clampType,
+ return fHelper.finalizeProcessors(caps, clip, hasMixedSampledCoverage, clampType,
GrProcessorAnalysisCoverage::kSingleChannel, &fColor,
nullptr);
}
@@ -1073,7 +1074,7 @@
bool GrAAHairLinePathRenderer::onDrawPath(const DrawPathArgs& args) {
GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(),
"GrAAHairlinePathRenderer::onDrawPath");
- SkASSERT(GrFSAAType::kUnifiedMSAA != args.fRenderTargetContext->fsaaType());
+ SkASSERT(args.fRenderTargetContext->numSamples() <= 1);
SkIRect devClipBounds;
args.fClip->getConservativeBounds(args.fRenderTargetContext->width(),
diff --git a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
index 5cbb89a..a66a9ae 100644
--- a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
@@ -40,7 +40,7 @@
GrPathRenderer::CanDrawPath
GrAALinearizingConvexPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
- if (!(AATypeFlags::kCoverage & args.fAATypeFlags)) {
+ if (GrAAType::kCoverage != args.fAAType) {
return CanDrawPath::kNo;
}
if (!args.fShape->knownToBeConvex()) {
@@ -187,11 +187,12 @@
FixedFunctionFlags fixedFunctionFlags() const override { return fHelper.fixedFunctionFlags(); }
- GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) override {
+ GrProcessorSet::Analysis finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) override {
return fHelper.finalizeProcessors(
- caps, clip, fsaaType, clampType, GrProcessorAnalysisCoverage::kSingleChannel,
- &fPaths.back().fColor, &fWideColor);
+ caps, clip, hasMixedSampledCoverage, clampType,
+ GrProcessorAnalysisCoverage::kSingleChannel, &fPaths.back().fColor, &fWideColor);
}
private:
@@ -337,7 +338,7 @@
bool GrAALinearizingConvexPathRenderer::onDrawPath(const DrawPathArgs& args) {
GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(),
"GrAALinearizingConvexPathRenderer::onDrawPath");
- SkASSERT(GrFSAAType::kUnifiedMSAA != args.fRenderTargetContext->fsaaType());
+ SkASSERT(args.fRenderTargetContext->numSamples() <= 1);
SkASSERT(!args.fShape->isEmpty());
SkASSERT(!args.fShape->style().pathEffect());
diff --git a/src/gpu/ops/GrAtlasTextOp.cpp b/src/gpu/ops/GrAtlasTextOp.cpp
index 998847d..1761acc 100644
--- a/src/gpu/ops/GrAtlasTextOp.cpp
+++ b/src/gpu/ops/GrAtlasTextOp.cpp
@@ -140,8 +140,9 @@
return FixedFunctionFlags::kNone;
}
-GrProcessorSet::Analysis GrAtlasTextOp::finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) {
+GrProcessorSet::Analysis GrAtlasTextOp::finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) {
GrProcessorAnalysisCoverage coverage;
GrProcessorAnalysisColor color;
if (kColorBitmapMask_MaskType == fMaskType) {
@@ -165,8 +166,8 @@
break;
}
auto analysis = fProcessors.finalize(
- color, coverage, clip, &GrUserStencilSettings::kUnused, fsaaType, caps, clampType,
- &fGeoData[0].fColor);
+ color, coverage, clip, &GrUserStencilSettings::kUnused, hasMixedSampledCoverage, caps,
+ clampType, &fGeoData[0].fColor);
fUsesLocalCoords = analysis.usesLocalCoords();
return analysis;
}
diff --git a/src/gpu/ops/GrAtlasTextOp.h b/src/gpu/ops/GrAtlasTextOp.h
index 2e42389..6b821e6 100644
--- a/src/gpu/ops/GrAtlasTextOp.h
+++ b/src/gpu/ops/GrAtlasTextOp.h
@@ -75,8 +75,8 @@
FixedFunctionFlags fixedFunctionFlags() const override;
- GrProcessorSet::Analysis finalize(const GrCaps&, const GrAppliedClip*, GrFSAAType,
- GrClampType) override;
+ GrProcessorSet::Analysis finalize(const GrCaps&, const GrAppliedClip*,
+ bool hasMixedSampledCoverage, GrClampType) override;
enum MaskType {
kGrayscaleCoverageMask_MaskType,
diff --git a/src/gpu/ops/GrDashLinePathRenderer.cpp b/src/gpu/ops/GrDashLinePathRenderer.cpp
index 5c06cfd..f15309c 100644
--- a/src/gpu/ops/GrDashLinePathRenderer.cpp
+++ b/src/gpu/ops/GrDashLinePathRenderer.cpp
@@ -18,9 +18,6 @@
SkPoint pts[2];
bool inverted;
if (args.fShape->style().isDashed() && args.fShape->asLine(pts, &inverted)) {
- if (args.fAATypeFlags == AATypeFlags::kMixedSampledStencilThenCover) {
- return CanDrawPath::kNo;
- }
// We should never have an inverse dashed case.
SkASSERT(!inverted);
if (!GrDashOp::CanDrawDashLine(pts, args.fShape->style(), *args.fViewMatrix)) {
@@ -34,16 +31,19 @@
bool GrDashLinePathRenderer::onDrawPath(const DrawPathArgs& args) {
GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(),
"GrDashLinePathRenderer::onDrawPath");
- GrDashOp::AAMode aaMode = GrDashOp::AAMode::kNone;
- if (AATypeFlags::kNone != args.fAATypeFlags) {
- if (AATypeFlags::kMSAA & args.fAATypeFlags) {
+ GrDashOp::AAMode aaMode;
+ switch (args.fAAType) {
+ case GrAAType::kNone:
+ aaMode = GrDashOp::AAMode::kNone;
+ 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 = GrDashOp::AAMode::kCoverageWithMSAA;
- } else {
- SkASSERT(AATypeFlags::kCoverage & args.fAATypeFlags);
+ break;
+ case GrAAType::kCoverage:
aaMode = GrDashOp::AAMode::kCoverage;
- }
+ break;
}
SkPoint pts[2];
SkAssertResult(args.fShape->asLine(pts, nullptr));
diff --git a/src/gpu/ops/GrDashOp.cpp b/src/gpu/ops/GrDashOp.cpp
index 4fcce84..89a7db6 100644
--- a/src/gpu/ops/GrDashOp.cpp
+++ b/src/gpu/ops/GrDashOp.cpp
@@ -258,7 +258,7 @@
}
GrProcessorSet::Analysis finalize(
- const GrCaps& caps, const GrAppliedClip* clip, GrFSAAType fsaaType,
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
GrClampType clampType) override {
GrProcessorAnalysisCoverage coverage;
if (AAMode::kNone == fAAMode && !clip->numClipCoverageFragmentProcessors()) {
@@ -267,7 +267,8 @@
coverage = GrProcessorAnalysisCoverage::kSingleChannel;
}
auto analysis = fProcessorSet.finalize(
- fColor, coverage, clip, fStencilSettings, fsaaType, caps, clampType, &fColor);
+ fColor, coverage, clip, fStencilSettings, hasMixedSampledCoverage, caps, clampType,
+ &fColor);
fUsesLocalCoords = analysis.usesLocalCoords();
return analysis;
}
@@ -1205,7 +1206,7 @@
AAMode aaMode;
do {
aaMode = static_cast<AAMode>(random->nextULessThan(GrDashOp::kAAModeCnt));
- } while (AAMode::kCoverageWithMSAA == aaMode && GrFSAAType::kUnifiedMSAA != fsaaType);
+ } while (AAMode::kCoverageWithMSAA == aaMode && numSamples <= 1);
// We can only dash either horizontal or vertical lines
SkPoint pts[2];
diff --git a/src/gpu/ops/GrDefaultPathRenderer.cpp b/src/gpu/ops/GrDefaultPathRenderer.cpp
index 2e3af82..2c4db58 100644
--- a/src/gpu/ops/GrDefaultPathRenderer.cpp
+++ b/src/gpu/ops/GrDefaultPathRenderer.cpp
@@ -388,14 +388,15 @@
FixedFunctionFlags fixedFunctionFlags() const override { return fHelper.fixedFunctionFlags(); }
- GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) override {
+ GrProcessorSet::Analysis finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) override {
GrProcessorAnalysisCoverage gpCoverage =
this->coverage() == 0xFF ? GrProcessorAnalysisCoverage::kNone
: GrProcessorAnalysisCoverage::kSingleChannel;
// This Op uses uniform (not vertex) color, so doesn't need to track wide color.
return fHelper.finalizeProcessors(
- caps, clip, fsaaType, clampType, gpCoverage, &fColor, nullptr);
+ caps, clip, hasMixedSampledCoverage, clampType, gpCoverage, &fColor, nullptr);
}
private:
@@ -646,7 +647,7 @@
return CanDrawPath::kNo;
}
// If antialiasing is required, we only support MSAA.
- if (AATypeFlags::kNone != args.fAATypeFlags && !(AATypeFlags::kMSAA & args.fAATypeFlags)) {
+ if (GrAAType::kNone != args.fAAType && GrAAType::kMSAA != args.fAAType) {
return CanDrawPath::kNo;
}
// This can draw any path with any simple fill style.
@@ -660,9 +661,7 @@
bool GrDefaultPathRenderer::onDrawPath(const DrawPathArgs& args) {
GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(),
"GrDefaultPathRenderer::onDrawPath");
- GrAAType aaType = (AATypeFlags::kNone != args.fAATypeFlags)
- ? GrAAType::kMSAA
- : GrAAType::kNone;
+ GrAAType aaType = (GrAAType::kNone != args.fAAType) ? GrAAType::kMSAA : GrAAType::kNone;
return this->internalDrawPath(
args.fRenderTargetContext, std::move(args.fPaint), aaType, *args.fUserStencilSettings,
@@ -704,7 +703,7 @@
viewMatrix.mapRect(&bounds);
uint8_t coverage = GrRandomCoverage(random);
GrAAType aaType = GrAAType::kNone;
- if (GrFSAAType::kUnifiedMSAA == fsaaType && random->nextBool()) {
+ if (numSamples > 1 && random->nextBool()) {
aaType = GrAAType::kMSAA;
}
return DefaultPathOp::Make(context, std::move(paint), path, srcSpaceTol, coverage, viewMatrix,
diff --git a/src/gpu/ops/GrDrawAtlasOp.cpp b/src/gpu/ops/GrDrawAtlasOp.cpp
index 34bea07..978e904 100644
--- a/src/gpu/ops/GrDrawAtlasOp.cpp
+++ b/src/gpu/ops/GrDrawAtlasOp.cpp
@@ -44,8 +44,8 @@
FixedFunctionFlags fixedFunctionFlags() const override;
- GrProcessorSet::Analysis finalize(const GrCaps&, const GrAppliedClip*, GrFSAAType,
- GrClampType) override;
+ GrProcessorSet::Analysis finalize(const GrCaps&, const GrAppliedClip*,
+ bool hasMixedSampledCoverage, GrClampType) override;
private:
void onPrepareDraws(Target*) override;
@@ -245,16 +245,17 @@
return fHelper.fixedFunctionFlags();
}
-GrProcessorSet::Analysis DrawAtlasOp::finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) {
+GrProcessorSet::Analysis DrawAtlasOp::finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) {
GrProcessorAnalysisColor gpColor;
if (this->hasColors()) {
gpColor.setToUnknown();
} else {
gpColor.setToConstant(fColor);
}
- auto result = fHelper.finalizeProcessors(
- caps, clip, fsaaType, clampType, GrProcessorAnalysisCoverage::kNone, &gpColor);
+ auto result = fHelper.finalizeProcessors(caps, clip, hasMixedSampledCoverage, clampType,
+ GrProcessorAnalysisCoverage::kNone, &gpColor);
if (gpColor.isConstant(&fColor)) {
fHasColors = false;
}
@@ -333,7 +334,7 @@
SkMatrix viewMatrix = GrTest::TestMatrix(random);
GrAAType aaType = GrAAType::kNone;
- if (GrFSAAType::kUnifiedMSAA == fsaaType && random->nextBool()) {
+ if (numSamples > 1 && random->nextBool()) {
aaType = GrAAType::kMSAA;
}
diff --git a/src/gpu/ops/GrDrawOp.h b/src/gpu/ops/GrDrawOp.h
index 5627ed3..a9e9752 100644
--- a/src/gpu/ops/GrDrawOp.h
+++ b/src/gpu/ops/GrDrawOp.h
@@ -43,8 +43,8 @@
* at this time the op must report whether a copy of the destination (or destination texture
* itself) needs to be provided to the GrXferProcessor when this op executes.
*/
- virtual GrProcessorSet::Analysis finalize(const GrCaps&, const GrAppliedClip*, GrFSAAType,
- GrClampType) = 0;
+ virtual GrProcessorSet::Analysis finalize(
+ const GrCaps&, const GrAppliedClip*, bool hasMixedSampledCoverage, GrClampType) = 0;
#ifdef SK_DEBUG
bool fAddDrawOpCalled = false;
diff --git a/src/gpu/ops/GrDrawPathOp.cpp b/src/gpu/ops/GrDrawPathOp.cpp
index 613b8a1..4388524 100644
--- a/src/gpu/ops/GrDrawPathOp.cpp
+++ b/src/gpu/ops/GrDrawPathOp.cpp
@@ -55,11 +55,11 @@
}
const GrProcessorSet::Analysis& GrDrawPathOpBase::doProcessorAnalysis(
- const GrCaps& caps, const GrAppliedClip* clip, GrFSAAType fsaaType,
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
GrClampType clampType) {
fAnalysis = fProcessorSet.finalize(
- fInputColor, GrProcessorAnalysisCoverage::kNone, clip, &kCoverPass, fsaaType, caps,
- clampType, &fInputColor);
+ fInputColor, GrProcessorAnalysisCoverage::kNone, clip, &kCoverPass,
+ hasMixedSampledCoverage, caps, clampType, &fInputColor);
return fAnalysis;
}
diff --git a/src/gpu/ops/GrDrawPathOp.h b/src/gpu/ops/GrDrawPathOp.h
index 95d266c..cd4ecc30 100644
--- a/src/gpu/ops/GrDrawPathOp.h
+++ b/src/gpu/ops/GrDrawPathOp.h
@@ -29,9 +29,10 @@
? FixedFunctionFlags::kUsesHWAA | FixedFunctionFlags::kUsesStencil
: FixedFunctionFlags::kUsesStencil;
}
- GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) override {
- return this->doProcessorAnalysis(caps, clip, fsaaType, clampType);
+ GrProcessorSet::Analysis finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) override {
+ return this->doProcessorAnalysis(caps, clip, hasMixedSampledCoverage, clampType);
}
void visitProxies(const VisitProxyFunc& func) const override {
@@ -46,7 +47,7 @@
GrProcessorSet detachProcessors() { return std::move(fProcessorSet); }
inline GrPipeline::InitArgs pipelineInitArgs(const GrOpFlushState&);
const GrProcessorSet::Analysis& doProcessorAnalysis(
- const GrCaps&, const GrAppliedClip*, GrFSAAType, GrClampType);
+ const GrCaps&, const GrAppliedClip*, bool hasMixedSampledCoverage, GrClampType);
const GrProcessorSet::Analysis& processorAnalysis() const {
SkASSERT(fAnalysis.isInitialized());
return fAnalysis;
diff --git a/src/gpu/ops/GrDrawVerticesOp.cpp b/src/gpu/ops/GrDrawVerticesOp.cpp
index 580edd6..272668e 100644
--- a/src/gpu/ops/GrDrawVerticesOp.cpp
+++ b/src/gpu/ops/GrDrawVerticesOp.cpp
@@ -38,8 +38,8 @@
FixedFunctionFlags fixedFunctionFlags() const override;
- GrProcessorSet::Analysis finalize(const GrCaps&, const GrAppliedClip*, GrFSAAType,
- GrClampType) override;
+ GrProcessorSet::Analysis finalize(const GrCaps&, const GrAppliedClip*,
+ bool hasMixedSampledCoverage, GrClampType) override;
private:
enum class ColorArrayType {
@@ -206,16 +206,17 @@
return fHelper.fixedFunctionFlags();
}
-GrProcessorSet::Analysis DrawVerticesOp::finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) {
+GrProcessorSet::Analysis DrawVerticesOp::finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) {
GrProcessorAnalysisColor gpColor;
if (this->requiresPerVertexColors()) {
gpColor.setToUnknown();
} else {
gpColor.setToConstant(fMeshes.front().fColor);
}
- auto result = fHelper.finalizeProcessors(
- caps, clip, fsaaType, clampType, GrProcessorAnalysisCoverage::kNone, &gpColor);
+ auto result = fHelper.finalizeProcessors(caps, clip, hasMixedSampledCoverage, clampType,
+ GrProcessorAnalysisCoverage::kNone, &gpColor);
if (gpColor.isConstant(&fMeshes.front().fColor)) {
fMeshes.front().fIgnoreColors = true;
fFlags &= ~kRequiresPerVertexColors_Flag;
@@ -698,7 +699,7 @@
hasIndices ? indices.count() : 0,
indices.begin());
GrAAType aaType = GrAAType::kNone;
- if (GrFSAAType::kUnifiedMSAA == fsaaType && random->nextBool()) {
+ if (numSamples > 1 && random->nextBool()) {
aaType = GrAAType::kMSAA;
}
return GrDrawVerticesOp::Make(context, std::move(paint), std::move(vertices), nullptr, 0,
diff --git a/src/gpu/ops/GrFillRRectOp.cpp b/src/gpu/ops/GrFillRRectOp.cpp
index d3f810e..e5e18b9 100644
--- a/src/gpu/ops/GrFillRRectOp.cpp
+++ b/src/gpu/ops/GrFillRRectOp.cpp
@@ -126,15 +126,17 @@
// We will write the color and local rect attribs during finalize().
}
-GrProcessorSet::Analysis GrFillRRectOp::finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) {
+GrProcessorSet::Analysis GrFillRRectOp::finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) {
SkASSERT(1 == fInstanceCount);
SkPMColor4f overrideColor;
const GrProcessorSet::Analysis& analysis = fProcessors.finalize(
fOriginalColor, GrProcessorAnalysisCoverage::kSingleChannel, clip,
- &GrUserStencilSettings::kUnused, fsaaType, caps, clampType, &overrideColor);
+ &GrUserStencilSettings::kUnused, hasMixedSampledCoverage, caps, clampType,
+ &overrideColor);
// Finish writing the instance attribs.
SkPMColor4f finalColor = analysis.inputColorIsOverridden() ? overrideColor : fOriginalColor;
diff --git a/src/gpu/ops/GrFillRRectOp.h b/src/gpu/ops/GrFillRRectOp.h
index 4bd2a23..a7678a1 100644
--- a/src/gpu/ops/GrFillRRectOp.h
+++ b/src/gpu/ops/GrFillRRectOp.h
@@ -26,8 +26,8 @@
? FixedFunctionFlags::kUsesHWAA
: FixedFunctionFlags::kNone;
}
- GrProcessorSet::Analysis finalize(
- const GrCaps&, const GrAppliedClip*, GrFSAAType, GrClampType) override;
+ GrProcessorSet::Analysis finalize(const GrCaps&, const GrAppliedClip*,
+ bool hasMixedSampledCoverage, GrClampType) override;
CombineResult onCombineIfPossible(GrOp*, const GrCaps&) override;
void visitProxies(const VisitProxyFunc& fn) const override {
fProcessors.visitProxies(fn);
diff --git a/src/gpu/ops/GrFillRectOp.cpp b/src/gpu/ops/GrFillRectOp.cpp
index 9935d51..f5f7c7c 100644
--- a/src/gpu/ops/GrFillRectOp.cpp
+++ b/src/gpu/ops/GrFillRectOp.cpp
@@ -121,8 +121,9 @@
}
#endif
- GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) override {
+ GrProcessorSet::Analysis finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) override {
// Initialize aggregate color analysis with the first quad's color (which always exists)
SkASSERT(this->quadCount() > 0);
GrProcessorAnalysisColor quadColors(fDeviceQuads.metadata(0).fColor);
@@ -143,7 +144,7 @@
GrProcessorAnalysisCoverage::kSingleChannel :
GrProcessorAnalysisCoverage::kNone;
auto result = fHelper.finalizeProcessors(
- caps, clip, fsaaType, clampType, coverage, &quadColors);
+ caps, clip, hasMixedSampledCoverage, clampType, coverage, &quadColors);
// If there is a constant color after analysis, that means all of the quads should be set
// to the same color (even if they started out with different colors).
SkPMColor4f colorOverride;
@@ -414,7 +415,7 @@
GrAAType aaType = GrAAType::kNone;
if (random->nextBool()) {
- aaType = (fsaaType == GrFSAAType::kUnifiedMSAA) ? GrAAType::kMSAA : GrAAType::kCoverage;
+ aaType = (numSamples > 1) ? GrAAType::kMSAA : GrAAType::kCoverage;
}
const GrUserStencilSettings* stencil = random->nextBool() ? nullptr
: GrGetRandomStencil(random, context);
diff --git a/src/gpu/ops/GrLatticeOp.cpp b/src/gpu/ops/GrLatticeOp.cpp
index 923fd98..96c9a72 100644
--- a/src/gpu/ops/GrLatticeOp.cpp
+++ b/src/gpu/ops/GrLatticeOp.cpp
@@ -194,15 +194,16 @@
FixedFunctionFlags fixedFunctionFlags() const override { return fHelper.fixedFunctionFlags(); }
- GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) override {
+ GrProcessorSet::Analysis finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) override {
auto opaque = fPatches[0].fColor.isOpaque() && GrPixelConfigIsOpaque(fProxy->config())
? GrProcessorAnalysisColor::Opaque::kYes
: GrProcessorAnalysisColor::Opaque::kNo;
auto analysisColor = GrProcessorAnalysisColor(opaque);
- auto result = fHelper.finalizeProcessors(caps, clip, fsaaType, clampType,
- GrProcessorAnalysisCoverage::kNone,
- &analysisColor);
+ auto result = fHelper.finalizeProcessors(
+ caps, clip, hasMixedSampledCoverage, clampType, GrProcessorAnalysisCoverage::kNone,
+ &analysisColor);
analysisColor.isConstant(&fPatches[0].fColor);
fWideColor = SkPMColor4fNeedsWideColor(fPatches[0].fColor, clampType, caps);
return result;
diff --git a/src/gpu/ops/GrOvalOpFactory.cpp b/src/gpu/ops/GrOvalOpFactory.cpp
index 5afd1d1..f6dfc8e 100644
--- a/src/gpu/ops/GrOvalOpFactory.cpp
+++ b/src/gpu/ops/GrOvalOpFactory.cpp
@@ -1221,10 +1221,11 @@
}
#endif
- GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) override {
+ GrProcessorSet::Analysis finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) override {
SkPMColor4f* color = &fCircles.front().fColor;
- return fHelper.finalizeProcessors(caps, clip, fsaaType, clampType,
+ return fHelper.finalizeProcessors(caps, clip, hasMixedSampledCoverage, clampType,
GrProcessorAnalysisCoverage::kSingleChannel, color,
&fWideColor);
}
@@ -1552,10 +1553,11 @@
}
#endif
- GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) override {
+ GrProcessorSet::Analysis finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) override {
SkPMColor4f* color = &fCircles.front().fColor;
- return fHelper.finalizeProcessors(caps, clip, fsaaType, clampType,
+ return fHelper.finalizeProcessors(caps, clip, hasMixedSampledCoverage, clampType,
GrProcessorAnalysisCoverage::kSingleChannel, color,
&fWideColor);
}
@@ -1848,12 +1850,13 @@
}
#endif
- GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) override {
+ GrProcessorSet::Analysis finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) override {
fUseScale = !caps.shaderCaps()->floatIs32Bits() &&
!caps.shaderCaps()->hasLowFragmentPrecision();
SkPMColor4f* color = &fEllipses.front().fColor;
- return fHelper.finalizeProcessors(caps, clip, fsaaType, clampType,
+ return fHelper.finalizeProcessors(caps, clip, hasMixedSampledCoverage, clampType,
GrProcessorAnalysisCoverage::kSingleChannel, color,
&fWideColor);
}
@@ -2090,12 +2093,13 @@
}
#endif
- GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) override {
+ GrProcessorSet::Analysis finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) override {
fUseScale = !caps.shaderCaps()->floatIs32Bits() &&
!caps.shaderCaps()->hasLowFragmentPrecision();
SkPMColor4f* color = &fEllipses.front().fColor;
- return fHelper.finalizeProcessors(caps, clip, fsaaType, clampType,
+ return fHelper.finalizeProcessors(caps, clip, hasMixedSampledCoverage, clampType,
GrProcessorAnalysisCoverage::kSingleChannel, color,
&fWideColor);
}
@@ -2414,10 +2418,11 @@
}
#endif
- GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) override {
+ GrProcessorSet::Analysis finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) override {
SkPMColor4f* color = &fRRects.front().fColor;
- return fHelper.finalizeProcessors(caps, clip, fsaaType, clampType,
+ return fHelper.finalizeProcessors(caps, clip, hasMixedSampledCoverage, clampType,
GrProcessorAnalysisCoverage::kSingleChannel, color,
&fWideColor);
}
@@ -2755,11 +2760,12 @@
}
#endif
- GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) override {
+ GrProcessorSet::Analysis finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) override {
fUseScale = !caps.shaderCaps()->floatIs32Bits();
SkPMColor4f* color = &fRRects.front().fColor;
- return fHelper.finalizeProcessors(caps, clip, fsaaType, clampType,
+ return fHelper.finalizeProcessors(caps, clip, hasMixedSampledCoverage, clampType,
GrProcessorAnalysisCoverage::kSingleChannel, color,
&fWideColor);
}
diff --git a/src/gpu/ops/GrRegionOp.cpp b/src/gpu/ops/GrRegionOp.cpp
index b1556fd..ba902ec 100644
--- a/src/gpu/ops/GrRegionOp.cpp
+++ b/src/gpu/ops/GrRegionOp.cpp
@@ -87,11 +87,12 @@
FixedFunctionFlags fixedFunctionFlags() const override { return fHelper.fixedFunctionFlags(); }
- GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) override {
- return fHelper.finalizeProcessors(caps, clip, fsaaType, clampType,
- GrProcessorAnalysisCoverage::kNone, &fRegions[0].fColor,
- &fWideColor);
+ GrProcessorSet::Analysis finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) override {
+ return fHelper.finalizeProcessors(
+ caps, clip, hasMixedSampledCoverage, clampType, GrProcessorAnalysisCoverage::kNone,
+ &fRegions[0].fColor, &fWideColor);
}
private:
@@ -211,7 +212,7 @@
}
SkMatrix viewMatrix = GrTest::TestMatrix(random);
GrAAType aaType = GrAAType::kNone;
- if (GrFSAAType::kUnifiedMSAA == fsaaType && random->nextBool()) {
+ if (numSamples > 1 && random->nextBool()) {
aaType = GrAAType::kMSAA;
}
return RegionOp::Make(context, std::move(paint), viewMatrix, region, aaType,
diff --git a/src/gpu/ops/GrShadowRRectOp.cpp b/src/gpu/ops/GrShadowRRectOp.cpp
index 20b8e09..34b6f94 100644
--- a/src/gpu/ops/GrShadowRRectOp.cpp
+++ b/src/gpu/ops/GrShadowRRectOp.cpp
@@ -255,8 +255,8 @@
FixedFunctionFlags fixedFunctionFlags() const override { return FixedFunctionFlags::kNone; }
- GrProcessorSet::Analysis finalize(
- const GrCaps&, const GrAppliedClip*, GrFSAAType, GrClampType) override {
+ GrProcessorSet::Analysis finalize(const GrCaps&, const GrAppliedClip*,
+ bool hasMixedSampledCoverage, GrClampType) override {
return GrProcessorSet::EmptySetAnalysis();
}
diff --git a/src/gpu/ops/GrSimpleMeshDrawOpHelper.cpp b/src/gpu/ops/GrSimpleMeshDrawOpHelper.cpp
index c255365..3c10b8b 100644
--- a/src/gpu/ops/GrSimpleMeshDrawOpHelper.cpp
+++ b/src/gpu/ops/GrSimpleMeshDrawOpHelper.cpp
@@ -61,11 +61,12 @@
}
GrProcessorSet::Analysis GrSimpleMeshDrawOpHelper::finalizeProcessors(
- const GrCaps& caps, const GrAppliedClip* clip, GrFSAAType fsaaType, GrClampType clampType,
- GrProcessorAnalysisCoverage geometryCoverage, SkPMColor4f* geometryColor, bool* wideColor) {
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType, GrProcessorAnalysisCoverage geometryCoverage,
+ SkPMColor4f* geometryColor, bool* wideColor) {
GrProcessorAnalysisColor color = *geometryColor;
auto result = this->finalizeProcessors(
- caps, clip, fsaaType, clampType, geometryCoverage, &color);
+ caps, clip, hasMixedSampledCoverage, clampType, geometryCoverage, &color);
color.isConstant(geometryColor);
if (wideColor) {
*wideColor = SkPMColor4fNeedsWideColor(*geometryColor, clampType, caps);
@@ -75,8 +76,8 @@
GrProcessorSet::Analysis GrSimpleMeshDrawOpHelper::finalizeProcessors(
const GrCaps& caps, const GrAppliedClip* clip, const GrUserStencilSettings* userStencil,
- GrFSAAType fsaaType, GrClampType clampType, GrProcessorAnalysisCoverage geometryCoverage,
- GrProcessorAnalysisColor* geometryColor) {
+ bool hasMixedSampledCoverage, GrClampType clampType,
+ GrProcessorAnalysisCoverage geometryCoverage, GrProcessorAnalysisColor* geometryColor) {
SkDEBUGCODE(fDidAnalysis = true);
GrProcessorSet::Analysis analysis;
if (fProcessors) {
@@ -87,8 +88,8 @@
: GrProcessorAnalysisCoverage::kNone;
}
SkPMColor4f overrideColor;
- analysis = fProcessors->finalize(*geometryColor, coverage, clip, userStencil, fsaaType,
- caps, clampType, &overrideColor);
+ analysis = fProcessors->finalize(*geometryColor, coverage, clip, userStencil,
+ hasMixedSampledCoverage, caps, clampType, &overrideColor);
if (analysis.inputColorIsOverridden()) {
*geometryColor = overrideColor;
}
@@ -139,9 +140,6 @@
case GrAAType::kMSAA:
result.append(" msaa\n");
break;
- case GrAAType::kMixedSamples:
- result.append(" mixed samples\n");
- break;
}
dump_pipeline_flags(fPipelineFlags, &result);
return result;
@@ -163,11 +161,12 @@
}
GrProcessorSet::Analysis GrSimpleMeshDrawOpHelperWithStencil::finalizeProcessors(
- const GrCaps& caps, const GrAppliedClip* clip, GrFSAAType fsaaType, GrClampType clampType,
- GrProcessorAnalysisCoverage geometryCoverage, SkPMColor4f* geometryColor, bool* wideColor) {
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType, GrProcessorAnalysisCoverage geometryCoverage,
+ SkPMColor4f* geometryColor, bool* wideColor) {
GrProcessorAnalysisColor color = *geometryColor;
auto result = this->finalizeProcessors(
- caps, clip, fsaaType, clampType, geometryCoverage, &color);
+ caps, clip, hasMixedSampledCoverage, clampType, geometryCoverage, &color);
color.isConstant(geometryColor);
if (wideColor) {
*wideColor = SkPMColor4fNeedsWideColor(*geometryColor, clampType, caps);
diff --git a/src/gpu/ops/GrSimpleMeshDrawOpHelper.h b/src/gpu/ops/GrSimpleMeshDrawOpHelper.h
index 3650fc5..35bf3cc 100644
--- a/src/gpu/ops/GrSimpleMeshDrawOpHelper.h
+++ b/src/gpu/ops/GrSimpleMeshDrawOpHelper.h
@@ -70,11 +70,12 @@
* color from its geometry processor instead.
*/
GrProcessorSet::Analysis finalizeProcessors(
- const GrCaps& caps, const GrAppliedClip* clip, GrFSAAType fsaaType,
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
GrClampType clampType, GrProcessorAnalysisCoverage geometryCoverage,
GrProcessorAnalysisColor* geometryColor) {
- return this->finalizeProcessors(caps, clip, &GrUserStencilSettings::kUnused, fsaaType,
- clampType, geometryCoverage, geometryColor);
+ return this->finalizeProcessors(
+ caps, clip, &GrUserStencilSettings::kUnused, hasMixedSampledCoverage, clampType,
+ geometryCoverage, geometryColor);
}
/**
@@ -83,7 +84,7 @@
* changed the op must override its geometry processor color output with the new color.
*/
GrProcessorSet::Analysis finalizeProcessors(
- const GrCaps&, const GrAppliedClip*, GrFSAAType, GrClampType,
+ const GrCaps&, const GrAppliedClip*, bool hasMixedSampledCoverage, GrClampType,
GrProcessorAnalysisCoverage geometryCoverage, SkPMColor4f* geometryColor,
bool* wideColor);
@@ -128,8 +129,8 @@
GrPipeline::InputFlags pipelineFlags() const { return fPipelineFlags; }
GrProcessorSet::Analysis finalizeProcessors(
- const GrCaps& caps, const GrAppliedClip*, const GrUserStencilSettings*, GrFSAAType,
- GrClampType, GrProcessorAnalysisCoverage geometryCoverage,
+ const GrCaps& caps, const GrAppliedClip*, const GrUserStencilSettings*,
+ bool hasMixedSampledCoverage, GrClampType, GrProcessorAnalysisCoverage geometryCoverage,
GrProcessorAnalysisColor* geometryColor);
GrProcessorSet* fProcessors;
@@ -167,17 +168,18 @@
GrDrawOp::FixedFunctionFlags fixedFunctionFlags() const;
GrProcessorSet::Analysis finalizeProcessors(
- const GrCaps& caps, const GrAppliedClip* clip, GrFSAAType fsaaType,
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
GrClampType clampType, GrProcessorAnalysisCoverage geometryCoverage,
GrProcessorAnalysisColor* geometryColor) {
return this->INHERITED::finalizeProcessors(
- caps, clip, fStencilSettings, fsaaType, clampType, geometryCoverage, geometryColor);
+ caps, clip, fStencilSettings, hasMixedSampledCoverage, clampType, geometryCoverage,
+ geometryColor);
}
GrProcessorSet::Analysis finalizeProcessors(
- const GrCaps&, const GrAppliedClip*, GrFSAAType, GrClampType,
- GrProcessorAnalysisCoverage geometryCoverage, SkPMColor4f* geometryColor,
- bool* wideColor);
+ const GrCaps&, const GrAppliedClip*, bool hasMixedSampledCoverage, GrClampType,
+ GrProcessorAnalysisCoverage geometryCoverage, SkPMColor4f* geometryColor, bool*
+ wideColor);
using GrSimpleMeshDrawOpHelper::aaType;
using GrSimpleMeshDrawOpHelper::setAAType;
diff --git a/src/gpu/ops/GrSmallPathRenderer.cpp b/src/gpu/ops/GrSmallPathRenderer.cpp
index 95d6f7c..f148ce0 100644
--- a/src/gpu/ops/GrSmallPathRenderer.cpp
+++ b/src/gpu/ops/GrSmallPathRenderer.cpp
@@ -189,7 +189,7 @@
return CanDrawPath::kNo;
}
// This does non-inverse coverage-based antialiased fills.
- if (!(AATypeFlags::kCoverage & args.fAATypeFlags)) {
+ if (GrAAType::kCoverage != args.fAAType) {
return CanDrawPath::kNo;
}
// TODO: Support inverse fill
@@ -297,11 +297,12 @@
FixedFunctionFlags fixedFunctionFlags() const override { return fHelper.fixedFunctionFlags(); }
- GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) override {
+ GrProcessorSet::Analysis finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) override {
return fHelper.finalizeProcessors(
- caps, clip, fsaaType, clampType, GrProcessorAnalysisCoverage::kSingleChannel,
- &fShapes.front().fColor, &fWideColor);
+ caps, clip, hasMixedSampledCoverage, clampType,
+ GrProcessorAnalysisCoverage::kSingleChannel, &fShapes.front().fColor, &fWideColor);
}
private:
diff --git a/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp b/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp
index 511599c..58f1037 100644
--- a/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp
+++ b/src/gpu/ops/GrStencilAndCoverPathRenderer.cpp
@@ -44,8 +44,8 @@
if (args.fHasUserStencilSettings) {
return CanDrawPath::kNo;
}
- // doesn't do per-path AA, relies on the target having MSAA.
- if (AATypeFlags::kCoverage == args.fAATypeFlags) {
+ // We rely on a mixed sampled stencil buffer to implement coverage AA.
+ if (GrAAType::kCoverage == args.fAAType) { // MIXED SAMPLES TODO: "&& !mixedSamplesSupport"
return CanDrawPath::kNo;
}
return CanDrawPath::kYes;
@@ -91,12 +91,14 @@
const SkMatrix& viewMatrix = *args.fViewMatrix;
- bool doStencilMSAA = AATypeFlags::kNone != args.fAATypeFlags;
- SkASSERT(!doStencilMSAA ||
- (AATypeFlags::kMSAA | AATypeFlags::kMixedSampledStencilThenCover) & args.fAATypeFlags);
+ bool doStencilMSAA = GrAAType::kNone != args.fAAType;
sk_sp<GrPath> path(get_gr_path(fResourceProvider, *args.fShape));
+ if (GrAAType::kCoverage == args.fAAType) {
+ // MIXED SAMPLES TODO: Indicate that we need a mixed sampled stencil buffer.
+ }
+
if (args.fShape->inverseFilled()) {
SkMatrix vmi;
if (!viewMatrix.invert(&vmi)) {
@@ -157,12 +159,12 @@
// 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.
GrAA doStencilMSAA = GrAA::kNo;
- if (AATypeFlags::kMSAA & args.fAATypeFlags) {
- SkASSERT(!(AATypeFlags::kMixedSampledStencilThenCover & args.fAATypeFlags));
+ if (GrAAType::kMSAA == args.fAAType) {
doStencilMSAA = GrAA::kYes;
}
- args.fRenderTargetContext->priv().stencilRect(*args.fClip, &kInvertedCoverPass,
- std::move(args.fPaint), doStencilMSAA, coverMatrix, coverBounds, &localMatrix);
+ args.fRenderTargetContext->priv().stencilRect(
+ *args.fClip, &kInvertedCoverPass, std::move(args.fPaint), doStencilMSAA,
+ coverMatrix, coverBounds, &localMatrix);
}
} else {
std::unique_ptr<GrDrawOp> op = GrDrawPathOp::Make(
diff --git a/src/gpu/ops/GrStrokeRectOp.cpp b/src/gpu/ops/GrStrokeRectOp.cpp
index a016c77..a435832 100644
--- a/src/gpu/ops/GrStrokeRectOp.cpp
+++ b/src/gpu/ops/GrStrokeRectOp.cpp
@@ -163,10 +163,11 @@
FixedFunctionFlags fixedFunctionFlags() const override { return fHelper.fixedFunctionFlags(); }
- GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) override {
+ GrProcessorSet::Analysis finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) override {
// This Op uses uniform (not vertex) color, so doesn't need to track wide color.
- return fHelper.finalizeProcessors(caps, clip, fsaaType, clampType,
+ return fHelper.finalizeProcessors(caps, clip, hasMixedSampledCoverage, clampType,
GrProcessorAnalysisCoverage::kNone, &fColor, nullptr);
}
@@ -409,11 +410,12 @@
FixedFunctionFlags fixedFunctionFlags() const override { return fHelper.fixedFunctionFlags(); }
- GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) override {
+ GrProcessorSet::Analysis finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) override {
return fHelper.finalizeProcessors(
- caps, clip, fsaaType, clampType, GrProcessorAnalysisCoverage::kSingleChannel,
- &fRects.back().fColor, &fWideColor);
+ caps, clip, hasMixedSampledCoverage, clampType,
+ GrProcessorAnalysisCoverage::kSingleChannel, &fRects.back().fColor, &fWideColor);
}
private:
@@ -799,7 +801,7 @@
strokePaint.setStrokeJoin(SkPaint::kMiter_Join);
SkStrokeRec strokeRec(strokePaint);
GrAAType aaType = GrAAType::kNone;
- if (fsaaType == GrFSAAType::kUnifiedMSAA) {
+ if (numSamples > 1) {
aaType = random->nextBool() ? GrAAType::kMSAA : GrAAType::kNone;
}
return NonAAStrokeRectOp::Make(context, std::move(paint), viewMatrix, rect, strokeRec, aaType);
diff --git a/src/gpu/ops/GrTessellatingPathRenderer.cpp b/src/gpu/ops/GrTessellatingPathRenderer.cpp
index b8f4cfb..f156449 100644
--- a/src/gpu/ops/GrTessellatingPathRenderer.cpp
+++ b/src/gpu/ops/GrTessellatingPathRenderer.cpp
@@ -150,21 +150,25 @@
if (!args.fShape->style().isSimpleFill() || args.fShape->knownToBeConvex()) {
return CanDrawPath::kNo;
}
- if (AATypeFlags::kNone == args.fAATypeFlags || (AATypeFlags::kMSAA & args.fAATypeFlags)) {
- // Prefer MSAA, if any antialiasing. In the non-analytic-AA case, We skip paths that don't
- // have a key since the real advantage of this path renderer comes from caching the
- // tessellated geometry.
- if (!args.fShape->hasUnstyledKey()) {
- return CanDrawPath::kNo;
- }
- } else if (AATypeFlags::kCoverage & args.fAATypeFlags) {
- // Use analytic AA if we don't have MSAA. In this case, we do not cache, so we accept paths
- // without keys.
- SkPath path;
- args.fShape->asPath(&path);
- if (path.countVerbs() > fMaxVerbCount) {
- return CanDrawPath::kNo;
- }
+ switch (args.fAAType) {
+ case GrAAType::kNone:
+ case GrAAType::kMSAA:
+ // Prefer MSAA, if any antialiasing. In the non-analytic-AA case, We skip paths that
+ // don't have a key since the real advantage of this path renderer comes from caching
+ // the tessellated geometry.
+ if (!args.fShape->hasUnstyledKey()) {
+ return CanDrawPath::kNo;
+ }
+ break;
+ case GrAAType::kCoverage:
+ // Use analytic AA if we don't have MSAA. In this case, we do not cache, so we accept
+ // paths without keys.
+ SkPath path;
+ args.fShape->asPath(&path);
+ if (path.countVerbs() > fMaxVerbCount) {
+ return CanDrawPath::kNo;
+ }
+ break;
}
return CanDrawPath::kYes;
}
@@ -232,14 +236,15 @@
FixedFunctionFlags fixedFunctionFlags() const override { return fHelper.fixedFunctionFlags(); }
- GrProcessorSet::Analysis finalize(const GrCaps& caps, const GrAppliedClip* clip,
- GrFSAAType fsaaType, GrClampType clampType) override {
+ GrProcessorSet::Analysis finalize(
+ const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
+ GrClampType clampType) override {
GrProcessorAnalysisCoverage coverage = fAntiAlias
? GrProcessorAnalysisCoverage::kSingleChannel
: GrProcessorAnalysisCoverage::kNone;
// This Op uses uniform (not vertex) color, so doesn't need to track wide color.
return fHelper.finalizeProcessors(
- caps, clip, fsaaType, clampType, coverage, &fColor, nullptr);
+ caps, clip, hasMixedSampledCoverage, clampType, coverage, &fColor, nullptr);
}
private:
@@ -397,15 +402,9 @@
args.fClip->getConservativeBounds(args.fRenderTargetContext->width(),
args.fRenderTargetContext->height(),
&clipBoundsI);
- GrAAType aaType = GrAAType::kNone;
- if (AATypeFlags::kMSAA & args.fAATypeFlags) {
- aaType = GrAAType::kMSAA;
- } else if (AATypeFlags::kCoverage & args.fAATypeFlags) {
- aaType = GrAAType::kCoverage;
- }
std::unique_ptr<GrDrawOp> op = TessellatingPathOp::Make(
args.fContext, std::move(args.fPaint), *args.fShape, *args.fViewMatrix, clipBoundsI,
- aaType, args.fUserStencilSettings);
+ args.fAAType, args.fUserStencilSettings);
args.fRenderTargetContext->addDrawOp(*args.fClip, std::move(op));
return true;
}
@@ -424,7 +423,7 @@
GrAAType aaType;
do {
aaType = kAATypes[random->nextULessThan(SK_ARRAY_COUNT(kAATypes))];
- } while(GrAAType::kMSAA == aaType && GrFSAAType::kUnifiedMSAA != fsaaType);
+ } while(GrAAType::kMSAA == aaType && numSamples <= 1);
GrStyle style;
do {
GrTest::TestStyle(random, &style);
diff --git a/src/gpu/ops/GrTextureOp.cpp b/src/gpu/ops/GrTextureOp.cpp
index f583777..d77e88b 100644
--- a/src/gpu/ops/GrTextureOp.cpp
+++ b/src/gpu/ops/GrTextureOp.cpp
@@ -223,7 +223,8 @@
#endif
GrProcessorSet::Analysis finalize(
- const GrCaps& caps, const GrAppliedClip*, GrFSAAType, GrClampType clampType) override {
+ const GrCaps& caps, const GrAppliedClip*, bool hasMixedSampledCoverage,
+ GrClampType clampType) override {
fColorType = static_cast<unsigned>(ColorType::kNone);
for (int q = 0; q < fQuads.count(); ++q) {
const ColorDomainAndAA& info = fQuads.metadata(q);
@@ -766,7 +767,7 @@
auto texXform = GrTest::TestColorXform(random);
GrAAType aaType = GrAAType::kNone;
if (random->nextBool()) {
- aaType = (fsaaType == GrFSAAType::kUnifiedMSAA) ? GrAAType::kMSAA : GrAAType::kCoverage;
+ aaType = (numSamples > 1) ? GrAAType::kMSAA : GrAAType::kCoverage;
}
GrQuadAAFlags aaFlags = GrQuadAAFlags::kNone;
aaFlags |= random->nextBool() ? GrQuadAAFlags::kLeft : GrQuadAAFlags::kNone;