Removing tracking of whether GP/FP coverage calculations are used by XP.
Remove readsCoverage from GrPipelineOptimizations
Remove kNone from GrDefaultGeoProc::Coverage
Remove kIgnoreCoverage from GrXferProcessor::OptFlags
Remove GrPipeline::fIgnoresCoverage
Change-Id: I8f0c9337ee98b9c77af1e9a8a184519ce63822d4
Reviewed-on: https://skia-review.googlesource.com/6552
Commit-Queue: Brian Salomon <bsalomon@google.com>
Reviewed-by: Greg Daniel <egdaniel@google.com>
diff --git a/src/gpu/GrDefaultGeoProcFactory.cpp b/src/gpu/GrDefaultGeoProcFactory.cpp
index 406fe6a..8970803 100644
--- a/src/gpu/GrDefaultGeoProcFactory.cpp
+++ b/src/gpu/GrDefaultGeoProcFactory.cpp
@@ -35,11 +35,9 @@
const SkMatrix& viewMatrix,
const SkMatrix& localMatrix,
bool localCoordsWillBeRead,
- bool coverageWillBeIgnored,
uint8_t coverage) {
return sk_sp<GrGeometryProcessor>(new DefaultGeoProc(
- gpTypeFlags, color, viewMatrix, localMatrix, coverage,
- localCoordsWillBeRead, coverageWillBeIgnored));
+ gpTypeFlags, color, viewMatrix, localMatrix, coverage, localCoordsWillBeRead));
}
const char* name() const override { return "DefaultGeometryProcessor"; }
@@ -55,7 +53,6 @@
const SkMatrix& localMatrix() const { return fLocalMatrix; }
bool localCoordsWillBeRead() const { return fLocalCoordsWillBeRead; }
uint8_t coverage() const { return fCoverage; }
- bool coverageWillBeIgnored() const { return fCoverageWillBeIgnored; }
bool hasVertexCoverage() const { return SkToBool(fInCoverage); }
class GLSLProcessor : public GrGLSLGeometryProcessor {
@@ -112,22 +109,20 @@
}
// Setup coverage as pass through
- if (!gp.coverageWillBeIgnored()) {
- if (gp.hasVertexCoverage()) {
- fragBuilder->codeAppendf("float alpha = 1.0;");
- varyingHandler->addPassThroughAttribute(gp.inCoverage(), "alpha");
- fragBuilder->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage);
- } else if (gp.coverage() == 0xff) {
- fragBuilder->codeAppendf("%s = vec4(1);", args.fOutputCoverage);
- } else {
- const char* fragCoverage;
- fCoverageUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
- kFloat_GrSLType,
- kDefault_GrSLPrecision,
- "Coverage",
- &fragCoverage);
- fragBuilder->codeAppendf("%s = vec4(%s);", args.fOutputCoverage, fragCoverage);
- }
+ if (gp.hasVertexCoverage()) {
+ fragBuilder->codeAppendf("float alpha = 1.0;");
+ varyingHandler->addPassThroughAttribute(gp.inCoverage(), "alpha");
+ fragBuilder->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage);
+ } else if (gp.coverage() == 0xff) {
+ fragBuilder->codeAppendf("%s = vec4(1);", args.fOutputCoverage);
+ } else {
+ const char* fragCoverage;
+ fCoverageUniform = uniformHandler->addUniform(kFragment_GrShaderFlag,
+ kFloat_GrSLType,
+ kDefault_GrSLPrecision,
+ "Coverage",
+ &fragCoverage);
+ fragBuilder->codeAppendf("%s = vec4(%s);", args.fOutputCoverage, fragCoverage);
}
}
@@ -137,12 +132,11 @@
const DefaultGeoProc& def = gp.cast<DefaultGeoProc>();
uint32_t key = def.fFlags;
key |= def.colorIgnored() << 8;
- key |= def.coverageWillBeIgnored() << 9;
- key |= def.hasVertexColor() << 10;
- key |= def.hasVertexCoverage() << 11;
- key |= def.coverage() == 0xff ? 0x1 << 12 : 0;
- key |= def.localCoordsWillBeRead() && def.localMatrix().hasPerspective() ? 0x1 << 24 :
- 0x0;
+ key |= def.hasVertexColor() << 9;
+ key |= def.hasVertexCoverage() << 10;
+ key |= (def.coverage() == 0xff) ? (0x1 << 11) : 0;
+ key |= (def.localCoordsWillBeRead() && def.localMatrix().hasPerspective()) ? (0x1 << 24)
+ : 0x0;
key |= ComputePosKey(def.viewMatrix()) << 25;
b->add32(key);
}
@@ -166,8 +160,7 @@
fColor = dgp.color();
}
- if (!dgp.coverageWillBeIgnored() &&
- dgp.coverage() != fCoverage && !dgp.hasVertexCoverage()) {
+ if (dgp.coverage() != fCoverage && !dgp.hasVertexCoverage()) {
pdman.set1f(fCoverageUniform, GrNormalizeByteToFloat(dgp.coverage()));
fCoverage = dgp.coverage();
}
@@ -199,19 +192,17 @@
const SkMatrix& viewMatrix,
const SkMatrix& localMatrix,
uint8_t coverage,
- bool localCoordsWillBeRead,
- bool coverageWillBeIgnored)
- : fInPosition(nullptr)
- , fInColor(nullptr)
- , fInLocalCoords(nullptr)
- , fInCoverage(nullptr)
- , fColor(color)
- , fViewMatrix(viewMatrix)
- , fLocalMatrix(localMatrix)
- , fCoverage(coverage)
- , fFlags(gpTypeFlags)
- , fLocalCoordsWillBeRead(localCoordsWillBeRead)
- , fCoverageWillBeIgnored(coverageWillBeIgnored) {
+ bool localCoordsWillBeRead)
+ : fInPosition(nullptr)
+ , fInColor(nullptr)
+ , fInLocalCoords(nullptr)
+ , fInCoverage(nullptr)
+ , fColor(color)
+ , fViewMatrix(viewMatrix)
+ , fLocalMatrix(localMatrix)
+ , fCoverage(coverage)
+ , fFlags(gpTypeFlags)
+ , fLocalCoordsWillBeRead(localCoordsWillBeRead) {
this->initClassID<DefaultGeoProc>();
bool hasColor = SkToBool(gpTypeFlags & kColor_GPFlag);
bool hasExplicitLocalCoords = SkToBool(gpTypeFlags & kLocalCoord_GPFlag);
@@ -241,7 +232,6 @@
uint8_t fCoverage;
uint32_t fFlags;
bool fLocalCoordsWillBeRead;
- bool fCoverageWillBeIgnored;
GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
@@ -267,7 +257,6 @@
GrTest::TestMatrix(d->fRandom),
GrTest::TestMatrix(d->fRandom),
d->fRandom->nextBool(),
- d->fRandom->nextBool(),
GrRandomCoverage(d->fRandom));
}
@@ -281,7 +270,6 @@
flags |= localCoords.fType == LocalCoords::kHasExplicit_Type ? kLocalCoord_GPFlag : 0;
uint8_t inCoverage = coverage.fCoverage;
- bool coverageWillBeIgnored = coverage.fType == Coverage::kNone_Type;
bool localCoordsWillBeRead = localCoords.fType != LocalCoords::kUnused_Type;
GrColor inColor = color.fColor;
@@ -290,7 +278,6 @@
viewMatrix,
localCoords.fMatrix ? *localCoords.fMatrix : SkMatrix::I(),
localCoordsWillBeRead,
- coverageWillBeIgnored,
inCoverage);
}
diff --git a/src/gpu/GrDefaultGeoProcFactory.h b/src/gpu/GrDefaultGeoProcFactory.h
index 688fcc9..238c154 100644
--- a/src/gpu/GrDefaultGeoProcFactory.h
+++ b/src/gpu/GrDefaultGeoProcFactory.h
@@ -66,7 +66,7 @@
kUniform_Type,
kAttribute_Type,
};
- Color(GrColor color) : fType(kUniform_Type), fColor(color) {}
+ explicit Color(GrColor color) : fType(kUniform_Type), fColor(color) {}
Color(Type type) : fType(type), fColor(GrColor_ILLEGAL) {
SkASSERT(type != kUniform_Type);
@@ -82,12 +82,11 @@
struct Coverage {
enum Type {
- kNone_Type,
kSolid_Type,
kUniform_Type,
kAttribute_Type,
};
- Coverage(uint8_t coverage) : fType(kUniform_Type), fCoverage(coverage) {}
+ explicit Coverage(uint8_t coverage) : fType(kUniform_Type), fCoverage(coverage) {}
Coverage(Type type) : fType(type), fCoverage(0xff) {
SkASSERT(type != kUniform_Type);
}
@@ -127,8 +126,6 @@
const Coverage&,
const LocalCoords&,
const SkMatrix& viewMatrix);
-
- inline size_t DefaultVertexStride() { return sizeof(PositionAttr); }
};
#endif
diff --git a/src/gpu/GrPathProcessor.cpp b/src/gpu/GrPathProcessor.cpp
index 5e1089c..3d78c62 100644
--- a/src/gpu/GrPathProcessor.cpp
+++ b/src/gpu/GrPathProcessor.cpp
@@ -21,7 +21,6 @@
const GrShaderCaps&,
GrProcessorKeyBuilder* b) {
b->add32(SkToInt(pathProc.optimizations().readsColor()) |
- (SkToInt(pathProc.optimizations().readsCoverage()) << 1) |
(SkToInt(pathProc.viewMatrix().hasPerspective()) << 2));
}
@@ -48,9 +47,7 @@
}
// setup constant solid coverage
- if (pathProc.optimizations().readsCoverage()) {
- fragBuilder->codeAppendf("%s = vec4(1);", args.fOutputCoverage);
- }
+ fragBuilder->codeAppendf("%s = vec4(1);", args.fOutputCoverage);
}
void emitTransforms(GrGLSLVaryingHandler* varyingHandler,
diff --git a/src/gpu/GrPipeline.cpp b/src/gpu/GrPipeline.cpp
index 2ca8e2c..2281829 100644
--- a/src/gpu/GrPipeline.cpp
+++ b/src/gpu/GrPipeline.cpp
@@ -146,9 +146,6 @@
optimizations->fFlags |= GrPipelineOptimizations::kUseOverrideColor_Flag;
optimizations->fOverrideColor = overrideColor;
}
- if (!SkToBool(optFlags & GrXferProcessor::kIgnoreCoverage_OptFlag)) {
- optimizations->fFlags |= GrPipelineOptimizations::kReadsCoverage_Flag;
- }
if (usesLocalCoords) {
optimizations->fFlags |= GrPipelineOptimizations::kReadsLocalCoords_Flag;
}
@@ -200,16 +197,10 @@
const GrProcOptInfo& coveragePOI,
int* firstColorProcessorIdx,
int* firstCoverageProcessorIdx) {
- fIgnoresCoverage = SkToBool(flags & GrXferProcessor::kIgnoreCoverage_OptFlag);
-
if ((flags & GrXferProcessor::kIgnoreColor_OptFlag) ||
(flags & GrXferProcessor::kOverrideColor_OptFlag)) {
*firstColorProcessorIdx = pipelineBuilder.numColorFragmentProcessors();
}
-
- if (flags & GrXferProcessor::kIgnoreCoverage_OptFlag) {
- *firstCoverageProcessorIdx = pipelineBuilder.numCoverageFragmentProcessors();
- }
}
////////////////////////////////////////////////////////////////////////////////
@@ -224,8 +215,7 @@
!a.fWindowRectsState.cheapEqualTo(b.fWindowRectsState) ||
a.fFlags != b.fFlags ||
a.fUserStencilSettings != b.fUserStencilSettings ||
- a.fDrawFace != b.fDrawFace ||
- a.fIgnoresCoverage != b.fIgnoresCoverage) {
+ a.fDrawFace != b.fDrawFace) {
return false;
}
diff --git a/src/gpu/GrPipeline.h b/src/gpu/GrPipeline.h
index e49dad4..3e25fda 100644
--- a/src/gpu/GrPipeline.h
+++ b/src/gpu/GrPipeline.h
@@ -199,10 +199,6 @@
GrDrawFace getDrawFace() const { return fDrawFace; }
- ///////////////////////////////////////////////////////////////////////////
-
- bool ignoresCoverage() const { return fIgnoresCoverage; }
-
private:
GrPipeline() { /** Initialized in factory function*/ }
@@ -246,7 +242,6 @@
uint32_t fFlags;
ProgramXferProcessor fXferProcessor;
FragmentProcessorArray fFragmentProcessors;
- bool fIgnoresCoverage;
// This value is also the index in fFragmentProcessors where coverage processors begin.
int fNumColorProcessors;
diff --git a/src/gpu/GrPrimitiveProcessor.h b/src/gpu/GrPrimitiveProcessor.h
index ed2b2e3..8d6a702 100644
--- a/src/gpu/GrPrimitiveProcessor.h
+++ b/src/gpu/GrPrimitiveProcessor.h
@@ -59,10 +59,6 @@
/** Does the pipeline require the GrPrimitiveProcessor's color? */
bool readsColor() const { return SkToBool(kReadsColor_Flag & fFlags); }
- /** Does the pipeline require the GrPrimitiveProcessor's coverage? */
- bool readsCoverage() const { return
- SkToBool(kReadsCoverage_Flag & fFlags); }
-
/** Does the pipeline require access to (implicit or explicit) local coordinates? */
bool readsLocalCoords() const {
return SkToBool(kReadsLocalCoords_Flag & fFlags);
@@ -103,23 +99,20 @@
private:
enum {
// If this is not set the primitive processor need not produce a color output
- kReadsColor_Flag = 0x1,
-
- // If this is not set the primitive processor need not produce a coverage output
- kReadsCoverage_Flag = 0x2,
+ kReadsColor_Flag = 0x1,
// If this is not set the primitive processor need not produce local coordinates
- kReadsLocalCoords_Flag = 0x4,
+ kReadsLocalCoords_Flag = 0x2,
// If this flag is set then the primitive processor may produce color*coverage as
// its color output (and not output a separate coverage).
- kCanTweakAlphaForCoverage_Flag = 0x8,
+ kCanTweakAlphaForCoverage_Flag = 0x4,
// If this flag is set the GrPrimitiveProcessor must produce fOverrideColor as its
// output color. If not set fOverrideColor is to be ignored.
- kUseOverrideColor_Flag = 0x10,
+ kUseOverrideColor_Flag = 0x8,
- kWillColorBlendWithDst_Flag = 0x20,
+ kWillColorBlendWithDst_Flag = 0x10,
};
uint32_t fFlags;
diff --git a/src/gpu/GrProgramDesc.cpp b/src/gpu/GrProgramDesc.cpp
index c6a1bcf..87a4a27 100644
--- a/src/gpu/GrProgramDesc.cpp
+++ b/src/gpu/GrProgramDesc.cpp
@@ -214,8 +214,6 @@
header->fOutputSwizzle = shaderCaps.configOutputSwizzle(rt->config()).asKey();
- header->fIgnoresCoverage = pipeline.ignoresCoverage() ? 1 : 0;
-
header->fSnapVerticesToPixelCenters = pipeline.snapVerticesToPixelCenters();
header->fColorFragmentProcessorCnt = pipeline.numColorFragmentProcessors();
header->fCoverageFragmentProcessorCnt = pipeline.numCoverageFragmentProcessors();
diff --git a/src/gpu/GrProgramDesc.h b/src/gpu/GrProgramDesc.h
index 5bb43f9..2a26f2d 100644
--- a/src/gpu/GrProgramDesc.h
+++ b/src/gpu/GrProgramDesc.h
@@ -103,10 +103,9 @@
uint8_t fCoverageFragmentProcessorCnt : 4;
// Set to uniquely identify the rt's origin, or 0 if the shader does not require this info.
uint8_t fSurfaceOriginKey : 2;
- uint8_t fIgnoresCoverage : 1;
uint8_t fSnapVerticesToPixelCenters : 1;
uint8_t fHasPointSize : 1;
- uint8_t fPad : 3;
+ uint8_t fPad : 4;
};
GR_STATIC_ASSERT(sizeof(KeyHeader) == 4);
diff --git a/src/gpu/GrXferProcessor.cpp b/src/gpu/GrXferProcessor.cpp
index 13533af..c2a16b8 100644
--- a/src/gpu/GrXferProcessor.cpp
+++ b/src/gpu/GrXferProcessor.cpp
@@ -37,14 +37,6 @@
const GrCaps& caps) const {
GrXferProcessor::OptFlags flags =
this->onGetOptimizations(analysis, doesStencilWrite, overrideColor, caps);
-
- if (this->willReadDstColor()) {
- // When performing a dst read we handle coverage in the base class.
- SkASSERT(!(flags & GrXferProcessor::kIgnoreCoverage_OptFlag));
- if (analysis.fCoveragePOI.isSolidWhite()) {
- flags |= GrXferProcessor::kIgnoreCoverage_OptFlag;
- }
- }
return flags;
}
diff --git a/src/gpu/effects/GrCustomXfermode.cpp b/src/gpu/effects/GrCustomXfermode.cpp
index 2ae8f9c..5f0127b 100644
--- a/src/gpu/effects/GrCustomXfermode.cpp
+++ b/src/gpu/effects/GrCustomXfermode.cpp
@@ -153,12 +153,8 @@
// Apply coverage by multiplying it into the src color before blending. Mixed samples will
// "just work" automatically. (See onGetOptimizations())
- if (args.fInputCoverage) {
- fragBuilder->codeAppendf("%s = %s * %s;",
- args.fOutputPrimary, args.fInputCoverage, args.fInputColor);
- } else {
- fragBuilder->codeAppendf("%s = %s;", args.fOutputPrimary, args.fInputColor);
- }
+ fragBuilder->codeAppendf("%s = %s * %s;", args.fOutputPrimary, args.fInputCoverage,
+ args.fInputColor);
}
void emitBlendCodeForDstRead(GrGLSLXPFragmentBuilder* fragBuilder,
@@ -306,9 +302,6 @@
if (analysis.fColorPOI.allStagesMultiplyInput()) {
flags |= kCanTweakAlphaForCoverage_OptFlag;
}
- if (this->hasHWBlendEquation() && analysis.fCoveragePOI.isSolidWhite()) {
- flags |= kIgnoreCoverage_OptFlag;
- }
return flags;
}
diff --git a/src/gpu/effects/GrDisableColorXP.cpp b/src/gpu/effects/GrDisableColorXP.cpp
index cfc7e03..0182acc 100644
--- a/src/gpu/effects/GrDisableColorXP.cpp
+++ b/src/gpu/effects/GrDisableColorXP.cpp
@@ -33,7 +33,7 @@
bool doesStencilWrite,
GrColor* color,
const GrCaps& caps) const override {
- return GrXferProcessor::kIgnoreColor_OptFlag | GrXferProcessor::kIgnoreCoverage_OptFlag;
+ return GrXferProcessor::kIgnoreColor_OptFlag;
}
void onGetGLSLProcessorKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override;
diff --git a/src/gpu/effects/GrPorterDuffXferProcessor.cpp b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
index a6b5bbb..df8b96d 100644
--- a/src/gpu/effects/GrPorterDuffXferProcessor.cpp
+++ b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
@@ -386,45 +386,27 @@
GrGLSLXPFragmentBuilder* fragBuilder,
BlendFormula::OutputType outputType, const char* output,
const char* inColor, const char* inCoverage) {
+ SkASSERT(inCoverage);
+ SkASSERT(inColor);
switch (outputType) {
case BlendFormula::kNone_OutputType:
fragBuilder->codeAppendf("%s = vec4(0.0);", output);
break;
case BlendFormula::kCoverage_OutputType:
// We can have a coverage formula while not reading coverage if there are mixed samples.
- if (inCoverage) {
- fragBuilder->codeAppendf("%s = %s;", output, inCoverage);
- } else {
- fragBuilder->codeAppendf("%s = vec4(1.0);", output);
- }
+ fragBuilder->codeAppendf("%s = %s;", output, inCoverage);
break;
case BlendFormula::kModulate_OutputType:
- if (inCoverage) {
- fragBuilder->codeAppendf("%s = %s * %s;", output, inColor, inCoverage);
- } else {
- fragBuilder->codeAppendf("%s = %s;", output, inColor);
- }
+ fragBuilder->codeAppendf("%s = %s * %s;", output, inColor, inCoverage);
break;
case BlendFormula::kSAModulate_OutputType:
- if (inCoverage) {
- fragBuilder->codeAppendf("%s = %s.a * %s;", output, inColor, inCoverage);
- } else {
- fragBuilder->codeAppendf("%s = %s;", output, inColor);
- }
+ fragBuilder->codeAppendf("%s = %s.a * %s;", output, inColor, inCoverage);
break;
case BlendFormula::kISAModulate_OutputType:
- if (inCoverage) {
- fragBuilder->codeAppendf("%s = (1.0 - %s.a) * %s;", output, inColor, inCoverage);
- } else {
- fragBuilder->codeAppendf("%s = vec4(1.0 - %s.a);", output, inColor);
- }
+ fragBuilder->codeAppendf("%s = (1.0 - %s.a) * %s;", output, inColor, inCoverage);
break;
case BlendFormula::kISCModulate_OutputType:
- if (inCoverage) {
- fragBuilder->codeAppendf("%s = (vec4(1.0) - %s) * %s;", output, inColor, inCoverage);
- } else {
- fragBuilder->codeAppendf("%s = vec4(1.0) - %s;", output, inColor);
- }
+ fragBuilder->codeAppendf("%s = (vec4(1.0) - %s) * %s;", output, inColor, inCoverage);
break;
default:
SkFAIL("Unsupported output type.");
@@ -482,15 +464,11 @@
optFlags |= GrXferProcessor::kSkipDraw_OptFlag;
}
optFlags |= (GrXferProcessor::kIgnoreColor_OptFlag |
- GrXferProcessor::kIgnoreCoverage_OptFlag |
GrXferProcessor::kCanTweakAlphaForCoverage_OptFlag);
} else {
if (!fBlendFormula.usesInputColor()) {
optFlags |= GrXferProcessor::kIgnoreColor_OptFlag;
}
- if (analysis.fCoveragePOI.isSolidWhite()) {
- optFlags |= GrXferProcessor::kIgnoreCoverage_OptFlag;
- }
if (analysis.fColorPOI.allStagesMultiplyInput() &&
fBlendFormula.canTweakAlphaForCoverage() &&
!analysis.fCoveragePOI.isFourChannelOutput()) {
diff --git a/src/gpu/glsl/GrGLSLProgramBuilder.cpp b/src/gpu/glsl/GrGLSLProgramBuilder.cpp
index 1182996..c805825 100644
--- a/src/gpu/glsl/GrGLSLProgramBuilder.cpp
+++ b/src/gpu/glsl/GrGLSLProgramBuilder.cpp
@@ -65,8 +65,7 @@
if (primProc.getPixelLocalStorageState() !=
GrPixelLocalStorageState::kDraw_GrPixelLocalStorageState) {
this->emitAndInstallXferProc(this->pipeline().getXferProcessor(), *inputColor,
- *inputCoverage, this->pipeline().ignoresCoverage(),
- primProc.getPixelLocalStorageState());
+ *inputCoverage, primProc.getPixelLocalStorageState());
this->emitFSOutputSwizzle(this->pipeline().getXferProcessor().hasSecondaryOutput());
}
@@ -206,7 +205,6 @@
void GrGLSLProgramBuilder::emitAndInstallXferProc(const GrXferProcessor& xp,
const GrGLSLExpr4& colorIn,
const GrGLSLExpr4& coverageIn,
- bool ignoresCoverage,
GrPixelLocalStorageState plsState) {
// Program builders have a bit of state we need to clear with each effect
AutoStageAdvance adv(this);
@@ -237,7 +235,7 @@
this->uniformHandler(),
this->shaderCaps(),
xp, colorIn.c_str(),
- ignoresCoverage ? nullptr : coverageIn.c_str(),
+ coverageIn.c_str(),
fFS.getPrimaryColorOutputName(),
fFS.getSecondaryColorOutputName(),
texSamplers.begin(),
diff --git a/src/gpu/glsl/GrGLSLProgramBuilder.h b/src/gpu/glsl/GrGLSLProgramBuilder.h
index bfd9f7a..2dba90f 100644
--- a/src/gpu/glsl/GrGLSLProgramBuilder.h
+++ b/src/gpu/glsl/GrGLSLProgramBuilder.h
@@ -159,7 +159,6 @@
void emitAndInstallXferProc(const GrXferProcessor&,
const GrGLSLExpr4& colorIn,
const GrGLSLExpr4& coverageIn,
- bool ignoresCoverage,
GrPixelLocalStorageState plsState);
void emitSamplersAndImageStorages(const GrProcessor& processor,
SkTArray<SamplerHandle>* outTexSamplerHandles,
diff --git a/src/gpu/instanced/InstanceProcessor.cpp b/src/gpu/instanced/InstanceProcessor.cpp
index e890247..8626eb9 100644
--- a/src/gpu/instanced/InstanceProcessor.cpp
+++ b/src/gpu/instanced/InstanceProcessor.cpp
@@ -354,8 +354,7 @@
}
SkASSERT(!(usedShapeDefinitions & (kRect_ShapeFlag | kComplexRRect_ShapeFlag)));
- backend->emitCode(v, f, pipeline.ignoresCoverage() ? nullptr : args.fOutputCoverage,
- args.fOutputColor);
+ backend->emitCode(v, f, args.fOutputCoverage, args.fOutputColor);
const char* localCoords = nullptr;
if (ip.opInfo().fUsesLocalCoords) {
diff --git a/src/gpu/ops/GrAAConvexPathRenderer.cpp b/src/gpu/ops/GrAAConvexPathRenderer.cpp
index 38e60c7..14106fe 100644
--- a/src/gpu/ops/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAAConvexPathRenderer.cpp
@@ -712,24 +712,18 @@
static sk_sp<GrGeometryProcessor> create_fill_gp(bool tweakAlphaForCoverage,
const SkMatrix& viewMatrix,
- bool usesLocalCoords,
- bool coverageIgnored) {
+ bool usesLocalCoords) {
using namespace GrDefaultGeoProcFactory;
- Color color(Color::kAttribute_Type);
Coverage::Type coverageType;
- // TODO remove coverage if coverage is ignored
- /*if (coverageIgnored) {
- coverageType = Coverage::kNone_Type;
- } else*/ if (tweakAlphaForCoverage) {
+ if (tweakAlphaForCoverage) {
coverageType = Coverage::kSolid_Type;
} else {
coverageType = Coverage::kAttribute_Type;
}
- Coverage coverage(coverageType);
- LocalCoords localCoords(usesLocalCoords ? LocalCoords::kUsePosition_Type :
- LocalCoords::kUnused_Type);
- return MakeForDeviceSpace(color, coverage, localCoords, viewMatrix);
+ LocalCoords::Type localCoordsType =
+ usesLocalCoords ? LocalCoords::kUsePosition_Type : LocalCoords::kUnused_Type;
+ return MakeForDeviceSpace(Color::kAttribute_Type, coverageType, localCoordsType, viewMatrix);
}
class AAConvexPathOp final : public GrMeshDrawOp {
@@ -769,7 +763,6 @@
optimizations.getOverrideColorIfSet(&fColor);
fUsesLocalCoords = optimizations.readsLocalCoords();
- fCoverageIgnored = !optimizations.readsCoverage();
fLinesOnly = SkPath::kLine_SegmentMask == fPaths[0].fPath.getSegmentMasks();
fCanTweakAlphaForCoverage = optimizations.canTweakAlphaForCoverage();
}
@@ -778,10 +771,8 @@
bool canTweakAlphaForCoverage = this->canTweakAlphaForCoverage();
// Setup GrGeometryProcessor
- sk_sp<GrGeometryProcessor> gp(create_fill_gp(canTweakAlphaForCoverage,
- this->viewMatrix(),
- this->usesLocalCoords(),
- this->coverageIgnored()));
+ sk_sp<GrGeometryProcessor> gp(create_fill_gp(
+ canTweakAlphaForCoverage, this->viewMatrix(), this->usesLocalCoords()));
if (!gp) {
SkDebugf("Could not create GrGeometryProcessor\n");
return;
@@ -963,11 +954,9 @@
bool usesLocalCoords() const { return fUsesLocalCoords; }
bool canTweakAlphaForCoverage() const { return fCanTweakAlphaForCoverage; }
const SkMatrix& viewMatrix() const { return fPaths[0].fViewMatrix; }
- bool coverageIgnored() const { return fCoverageIgnored; }
GrColor fColor;
bool fUsesLocalCoords;
- bool fCoverageIgnored;
bool fLinesOnly;
bool fCanTweakAlphaForCoverage;
diff --git a/src/gpu/ops/GrAADistanceFieldPathRenderer.cpp b/src/gpu/ops/GrAADistanceFieldPathRenderer.cpp
index a21d40b..fc141f7 100644
--- a/src/gpu/ops/GrAADistanceFieldPathRenderer.cpp
+++ b/src/gpu/ops/GrAADistanceFieldPathRenderer.cpp
@@ -177,7 +177,6 @@
fColorIgnored = !optimizations.readsColor();
fUsesLocalCoords = optimizations.readsLocalCoords();
- fCoverageIgnored = !optimizations.readsCoverage();
}
struct FlushInfo {
@@ -488,7 +487,6 @@
SkMatrix fViewMatrix;
bool fUsesLocalCoords;
bool fColorIgnored;
- bool fCoverageIgnored;
struct Entry {
GrColor fColor;
diff --git a/src/gpu/ops/GrAAFillRectOp.cpp b/src/gpu/ops/GrAAFillRectOp.cpp
index 2189d86..6ef48cb 100644
--- a/src/gpu/ops/GrAAFillRectOp.cpp
+++ b/src/gpu/ops/GrAAFillRectOp.cpp
@@ -220,11 +220,10 @@
} else {
coverageType = Coverage::kAttribute_Type;
}
- Coverage coverage(coverageType);
LocalCoords lc =
needLocalCoords ? LocalCoords::kHasExplicit_Type : LocalCoords::kUnused_Type;
sk_sp<GrGeometryProcessor> gp =
- GrDefaultGeoProcFactory::Make(color, coverage, lc, SkMatrix::I());
+ GrDefaultGeoProcFactory::Make(color, coverageType, lc, SkMatrix::I());
if (!gp) {
SkDebugf("Couldn't create GrGeometryProcessor\n");
return;
diff --git a/src/gpu/ops/GrAAHairLinePathRenderer.cpp b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
index 6edef91..c8533cb 100644
--- a/src/gpu/ops/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
@@ -840,11 +840,10 @@
using namespace GrDefaultGeoProcFactory;
Color color(this->color());
- Coverage coverage(Coverage::kAttribute_Type);
LocalCoords localCoords(this->usesLocalCoords() ? LocalCoords::kUsePosition_Type :
LocalCoords::kUnused_Type);
localCoords.fMatrix = geometryProcessorLocalM;
- lineGP = GrDefaultGeoProcFactory::Make(color, coverage, localCoords,
+ lineGP = GrDefaultGeoProcFactory::Make(color, Coverage::kAttribute_Type, localCoords,
*geometryProcessorViewM);
}
diff --git a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
index aa46ed3..03e5ce3 100644
--- a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
@@ -103,24 +103,18 @@
static sk_sp<GrGeometryProcessor> create_fill_gp(bool tweakAlphaForCoverage,
const SkMatrix& viewMatrix,
- bool usesLocalCoords,
- bool coverageIgnored) {
+ bool usesLocalCoords) {
using namespace GrDefaultGeoProcFactory;
- Color color(Color::kAttribute_Type);
Coverage::Type coverageType;
- // TODO remove coverage if coverage is ignored
- /*if (coverageIgnored) {
- coverageType = Coverage::kNone_Type;
- } else*/ if (tweakAlphaForCoverage) {
+ if (tweakAlphaForCoverage) {
coverageType = Coverage::kSolid_Type;
} else {
coverageType = Coverage::kAttribute_Type;
}
- Coverage coverage(coverageType);
- LocalCoords localCoords(usesLocalCoords ? LocalCoords::kUsePosition_Type :
- LocalCoords::kUnused_Type);
- return MakeForDeviceSpace(color, coverage, localCoords, viewMatrix);
+ LocalCoords::Type localCoordsType =
+ usesLocalCoords ? LocalCoords::kUsePosition_Type : LocalCoords::kUnused_Type;
+ return MakeForDeviceSpace(Color::kAttribute_Type, coverageType, localCoordsType, viewMatrix);
}
class AAFlatteningConvexPathOp final : public GrMeshDrawOp {
@@ -191,7 +185,6 @@
fColor = fPaths[0].fColor;
fUsesLocalCoords = optimizations.readsLocalCoords();
- fCoverageIgnored = !optimizations.readsCoverage();
fCanTweakAlphaForCoverage = optimizations.canTweakAlphaForCoverage();
}
@@ -228,10 +221,8 @@
bool canTweakAlphaForCoverage = this->canTweakAlphaForCoverage();
// Setup GrGeometryProcessor
- sk_sp<GrGeometryProcessor> gp(create_fill_gp(canTweakAlphaForCoverage,
- this->viewMatrix(),
- this->usesLocalCoords(),
- this->coverageIgnored()));
+ sk_sp<GrGeometryProcessor> gp(create_fill_gp(
+ canTweakAlphaForCoverage, this->viewMatrix(), this->usesLocalCoords()));
if (!gp) {
SkDebugf("Couldn't create a GrGeometryProcessor\n");
return;
@@ -317,7 +308,6 @@
bool usesLocalCoords() const { return fUsesLocalCoords; }
bool canTweakAlphaForCoverage() const { return fCanTweakAlphaForCoverage; }
const SkMatrix& viewMatrix() const { return fPaths[0].fViewMatrix; }
- bool coverageIgnored() const { return fCoverageIgnored; }
struct PathData {
GrColor fColor;
@@ -331,7 +321,6 @@
GrColor fColor;
bool fUsesLocalCoords;
- bool fCoverageIgnored;
bool fCanTweakAlphaForCoverage;
SkSTArray<1, PathData, true> fPaths;
diff --git a/src/gpu/ops/GrAAStrokeRectOp.cpp b/src/gpu/ops/GrAAStrokeRectOp.cpp
index 1ececb3..3c603bb 100644
--- a/src/gpu/ops/GrAAStrokeRectOp.cpp
+++ b/src/gpu/ops/GrAAStrokeRectOp.cpp
@@ -97,17 +97,15 @@
bool usesLocalCoords) {
using namespace GrDefaultGeoProcFactory;
- Color color(Color::kAttribute_Type);
Coverage::Type coverageType;
if (tweakAlphaForCoverage) {
coverageType = Coverage::kSolid_Type;
} else {
coverageType = Coverage::kAttribute_Type;
}
- Coverage coverage(coverageType);
- LocalCoords localCoords(usesLocalCoords ? LocalCoords::kUsePosition_Type
- : LocalCoords::kUnused_Type);
- return MakeForDeviceSpace(color, coverage, localCoords, viewMatrix);
+ LocalCoords::Type localCoordsType =
+ usesLocalCoords ? LocalCoords::kUsePosition_Type : LocalCoords::kUnused_Type;
+ return MakeForDeviceSpace(Color::kAttribute_Type, coverageType, localCoordsType, viewMatrix);
}
class AAStrokeRectOp final : public GrMeshDrawOp {
diff --git a/src/gpu/ops/GrAtlasTextOp.cpp b/src/gpu/ops/GrAtlasTextOp.cpp
index c4c9170..8705bac 100644
--- a/src/gpu/ops/GrAtlasTextOp.cpp
+++ b/src/gpu/ops/GrAtlasTextOp.cpp
@@ -75,7 +75,6 @@
fColorIgnored = !optimizations.readsColor();
fColor = fGeoData[0].fColor;
fUsesLocalCoords = optimizations.readsLocalCoords();
- fCoverageIgnored = !optimizations.readsCoverage();
}
void GrAtlasTextOp::onPrepareDraws(Target* target) const {
diff --git a/src/gpu/ops/GrAtlasTextOp.h b/src/gpu/ops/GrAtlasTextOp.h
index ef72477..781e580 100644
--- a/src/gpu/ops/GrAtlasTextOp.h
+++ b/src/gpu/ops/GrAtlasTextOp.h
@@ -154,7 +154,6 @@
GrColor fColor;
bool fUsesLocalCoords;
bool fColorIgnored;
- bool fCoverageIgnored;
int fNumGlyphs;
// The minimum number of Geometry we will try to allocate.
diff --git a/src/gpu/ops/GrDashOp.cpp b/src/gpu/ops/GrDashOp.cpp
index 5ff3230..caeff3d 100644
--- a/src/gpu/ops/GrDashOp.cpp
+++ b/src/gpu/ops/GrDashOp.cpp
@@ -309,7 +309,6 @@
optimizations.getOverrideColorIfSet(&fColor);
fUsesLocalCoords = optimizations.readsLocalCoords();
- fCoverageIgnored = !optimizations.readsCoverage();
}
struct DashDraw {
@@ -346,11 +345,11 @@
// Set up the vertex data for the line and start/end dashes
using namespace GrDefaultGeoProcFactory;
Color color(this->color());
- Coverage coverage(this->coverageIgnored() ? Coverage::kNone_Type :
- Coverage::kSolid_Type);
- LocalCoords localCoords(this->usesLocalCoords() ? LocalCoords::kUsePosition_Type :
- LocalCoords::kUnused_Type);
- gp = MakeForDeviceSpace(color, coverage, localCoords, this->viewMatrix());
+ LocalCoords::Type localCoordsType = this->usesLocalCoords()
+ ? LocalCoords::kUsePosition_Type
+ : LocalCoords::kUnused_Type;
+ gp = MakeForDeviceSpace(color, Coverage::kSolid_Type, localCoordsType,
+ this->viewMatrix());
}
if (!gp) {
@@ -672,14 +671,12 @@
AAMode aaMode() const { return fAAMode; }
bool fullDash() const { return fFullDash; }
SkPaint::Cap cap() const { return fCap; }
- bool coverageIgnored() const { return fCoverageIgnored; }
static const int kVertsPerDash = 4;
static const int kIndicesPerDash = 6;
GrColor fColor;
bool fUsesLocalCoords;
- bool fCoverageIgnored;
SkPaint::Cap fCap;
AAMode fAAMode;
bool fFullDash;
diff --git a/src/gpu/ops/GrDefaultPathRenderer.cpp b/src/gpu/ops/GrDefaultPathRenderer.cpp
index c20a3d5..2b2501e 100644
--- a/src/gpu/ops/GrDefaultPathRenderer.cpp
+++ b/src/gpu/ops/GrDefaultPathRenderer.cpp
@@ -143,7 +143,6 @@
}
optimizations.getOverrideColorIfSet(&fColor);
fUsesLocalCoords = optimizations.readsLocalCoords();
- fCoverageIgnored = !optimizations.readsCoverage();
}
void onPrepareDraws(Target* target) const override {
@@ -152,9 +151,6 @@
using namespace GrDefaultGeoProcFactory;
Color color(this->color());
Coverage coverage(this->coverage());
- if (this->coverageIgnored()) {
- coverage.fType = Coverage::kNone_Type;
- }
LocalCoords localCoords(this->usesLocalCoords() ? LocalCoords::kUsePosition_Type :
LocalCoords::kUnused_Type);
gp = GrDefaultGeoProcFactory::Make(color, coverage, localCoords, this->viewMatrix());
@@ -395,7 +391,6 @@
bool usesLocalCoords() const { return fUsesLocalCoords; }
const SkMatrix& viewMatrix() const { return fViewMatrix; }
bool isHairline() const { return fIsHairline; }
- bool coverageIgnored() const { return fCoverageIgnored; }
struct PathData {
SkPath fPath;
@@ -406,7 +401,6 @@
uint8_t fCoverage;
SkMatrix fViewMatrix;
bool fUsesLocalCoords;
- bool fCoverageIgnored;
bool fIsHairline;
SkSTArray<1, PathData, true> fPaths;
diff --git a/src/gpu/ops/GrDrawAtlasOp.cpp b/src/gpu/ops/GrDrawAtlasOp.cpp
index eac8f96..2c8e34b 100644
--- a/src/gpu/ops/GrDrawAtlasOp.cpp
+++ b/src/gpu/ops/GrDrawAtlasOp.cpp
@@ -31,28 +31,24 @@
fColor = fGeoData[0].fColor;
// We'd like to assert this, but we can't because of GLPrograms test
// SkASSERT(init.readsLocalCoords());
- fCoverageIgnored = !optimizations.readsCoverage();
}
-static sk_sp<GrGeometryProcessor> set_vertex_attributes(bool hasColors,
- GrColor color,
- const SkMatrix& viewMatrix,
- bool coverageIgnored) {
+static sk_sp<GrGeometryProcessor> make_gp(bool hasColors,
+ GrColor color,
+ const SkMatrix& viewMatrix) {
using namespace GrDefaultGeoProcFactory;
Color gpColor(color);
if (hasColors) {
gpColor.fType = Color::kAttribute_Type;
}
- Coverage coverage(coverageIgnored ? Coverage::kNone_Type : Coverage::kSolid_Type);
- LocalCoords localCoords(LocalCoords::kHasExplicit_Type);
- return GrDefaultGeoProcFactory::Make(gpColor, coverage, localCoords, viewMatrix);
+ return GrDefaultGeoProcFactory::Make(gpColor, Coverage::kSolid_Type,
+ LocalCoords::kHasExplicit_Type, viewMatrix);
}
void GrDrawAtlasOp::onPrepareDraws(Target* target) const {
// Setup geometry processor
- sk_sp<GrGeometryProcessor> gp(set_vertex_attributes(
- this->hasColors(), this->color(), this->viewMatrix(), this->coverageIgnored()));
+ sk_sp<GrGeometryProcessor> gp(make_gp(this->hasColors(), this->color(), this->viewMatrix()));
int instanceCount = fGeoData.count();
size_t vertexStride = gp->getVertexStride();
diff --git a/src/gpu/ops/GrDrawAtlasOp.h b/src/gpu/ops/GrDrawAtlasOp.h
index 60158e0..8251386 100644
--- a/src/gpu/ops/GrDrawAtlasOp.h
+++ b/src/gpu/ops/GrDrawAtlasOp.h
@@ -57,7 +57,6 @@
const SkMatrix& viewMatrix() const { return fViewMatrix; }
bool hasColors() const { return fHasColors; }
int quadCount() const { return fQuadCount; }
- bool coverageIgnored() const { return fCoverageIgnored; }
bool onCombineIfPossible(GrOp* t, const GrCaps&) override;
@@ -72,7 +71,6 @@
GrColor fColor;
int fQuadCount;
bool fColorIgnored;
- bool fCoverageIgnored;
bool fHasColors;
typedef GrMeshDrawOp INHERITED;
diff --git a/src/gpu/ops/GrDrawVerticesOp.cpp b/src/gpu/ops/GrDrawVerticesOp.cpp
index db505f9..ed2c072 100644
--- a/src/gpu/ops/GrDrawVerticesOp.cpp
+++ b/src/gpu/ops/GrDrawVerticesOp.cpp
@@ -14,21 +14,19 @@
static sk_sp<GrGeometryProcessor> set_vertex_attributes(bool hasLocalCoords,
int* colorOffset,
int* texOffset,
- const SkMatrix& viewMatrix,
- bool coverageIgnored) {
+ const SkMatrix& viewMatrix) {
using namespace GrDefaultGeoProcFactory;
*texOffset = -1;
*colorOffset = -1;
- Coverage coverage(coverageIgnored ? Coverage::kNone_Type : Coverage::kSolid_Type);
- LocalCoords localCoords(hasLocalCoords ? LocalCoords::kHasExplicit_Type
- : LocalCoords::kUsePosition_Type);
+ LocalCoords::Type localCoordsType =
+ hasLocalCoords ? LocalCoords::kHasExplicit_Type : LocalCoords::kUsePosition_Type;
*colorOffset = sizeof(SkPoint);
if (hasLocalCoords) {
*texOffset = sizeof(SkPoint) + sizeof(GrColor);
}
- return GrDefaultGeoProcFactory::Make(Color(Color::kAttribute_Type), coverage, localCoords,
- viewMatrix);
+ return GrDefaultGeoProcFactory::Make(Color::kAttribute_Type, Coverage::kSolid_Type,
+ localCoordsType, viewMatrix);
}
GrDrawVerticesOp::GrDrawVerticesOp(GrColor color, GrPrimitiveType primitiveType,
@@ -88,7 +86,6 @@
fMeshes[0].fColors.reset();
fVariableColor = false;
}
- fCoverageIgnored = !optimizations.readsCoverage();
if (!optimizations.readsLocalCoords()) {
fMeshes[0].fLocalCoords.reset();
}
@@ -97,8 +94,8 @@
void GrDrawVerticesOp::onPrepareDraws(Target* target) const {
bool hasLocalCoords = !fMeshes[0].fLocalCoords.isEmpty();
int colorOffset = -1, texOffset = -1;
- sk_sp<GrGeometryProcessor> gp(set_vertex_attributes(hasLocalCoords, &colorOffset, &texOffset,
- fViewMatrix, fCoverageIgnored));
+ sk_sp<GrGeometryProcessor> gp(
+ set_vertex_attributes(hasLocalCoords, &colorOffset, &texOffset, fViewMatrix));
size_t vertexStride = gp->getVertexStride();
SkASSERT(vertexStride ==
diff --git a/src/gpu/ops/GrDrawVerticesOp.h b/src/gpu/ops/GrDrawVerticesOp.h
index b0697f4..680b41f 100644
--- a/src/gpu/ops/GrDrawVerticesOp.h
+++ b/src/gpu/ops/GrDrawVerticesOp.h
@@ -75,7 +75,6 @@
bool fVariableColor;
int fVertexCount;
int fIndexCount;
- bool fCoverageIgnored; // comes from applyPipelineOptimizations.
SkSTArray<1, Mesh, true> fMeshes;
diff --git a/src/gpu/ops/GrLatticeOp.cpp b/src/gpu/ops/GrLatticeOp.cpp
index e3881ba..9141b34 100644
--- a/src/gpu/ops/GrLatticeOp.cpp
+++ b/src/gpu/ops/GrLatticeOp.cpp
@@ -15,12 +15,10 @@
#include "SkLatticeIter.h"
#include "SkRect.h"
-static sk_sp<GrGeometryProcessor> create_gp(bool readsCoverage) {
+static sk_sp<GrGeometryProcessor> create_gp() {
using namespace GrDefaultGeoProcFactory;
- Color color(Color::kAttribute_Type);
- Coverage coverage(readsCoverage ? Coverage::kSolid_Type : Coverage::kNone_Type);
- LocalCoords localCoords(LocalCoords::kHasExplicit_Type);
- return GrDefaultGeoProcFactory::Make(color, coverage, localCoords, SkMatrix::I());
+ return GrDefaultGeoProcFactory::Make(Color::kAttribute_Type, Coverage::kSolid_Type,
+ LocalCoords::kHasExplicit_Type, SkMatrix::I());
}
class NonAALatticeOp final : public GrMeshDrawOp {
@@ -74,7 +72,7 @@
}
void onPrepareDraws(Target* target) const override {
- sk_sp<GrGeometryProcessor> gp(create_gp(fOptimizations.readsCoverage()));
+ sk_sp<GrGeometryProcessor> gp(create_gp());
if (!gp) {
SkDebugf("Couldn't create GrGeometryProcessor\n");
return;
diff --git a/src/gpu/ops/GrMSAAPathRenderer.cpp b/src/gpu/ops/GrMSAAPathRenderer.cpp
index 0774fdb..a45e6fa 100644
--- a/src/gpu/ops/GrMSAAPathRenderer.cpp
+++ b/src/gpu/ops/GrMSAAPathRenderer.cpp
@@ -404,7 +404,7 @@
{
using namespace GrDefaultGeoProcFactory;
lineGP = GrDefaultGeoProcFactory::Make(Color(Color::kAttribute_Type),
- Coverage(255),
+ Coverage::kSolid_Type,
LocalCoords(LocalCoords::kUnused_Type),
fViewMatrix);
}
diff --git a/src/gpu/ops/GrNonAAFillRectOp.cpp b/src/gpu/ops/GrNonAAFillRectOp.cpp
index 26bee83..1e4fde4 100644
--- a/src/gpu/ops/GrNonAAFillRectOp.cpp
+++ b/src/gpu/ops/GrNonAAFillRectOp.cpp
@@ -28,13 +28,10 @@
The vertex attrib order is always pos, color, [local coords].
*/
-static sk_sp<GrGeometryProcessor> make_gp(bool readsCoverage) {
+static sk_sp<GrGeometryProcessor> make_gp() {
using namespace GrDefaultGeoProcFactory;
- Color color(Color::kAttribute_Type);
- Coverage coverage(readsCoverage ? Coverage::kSolid_Type : Coverage::kNone_Type);
-
- LocalCoords localCoords(LocalCoords::kHasExplicit_Type);
- return GrDefaultGeoProcFactory::Make(color, coverage, localCoords, SkMatrix::I());
+ return GrDefaultGeoProcFactory::Make(Color::kAttribute_Type, Coverage::kSolid_Type,
+ LocalCoords::kHasExplicit_Type, SkMatrix::I());
}
static void tesselate(intptr_t vertices,
@@ -124,7 +121,7 @@
}
void onPrepareDraws(Target* target) const override {
- sk_sp<GrGeometryProcessor> gp = make_gp(fOptimizations.readsCoverage());
+ sk_sp<GrGeometryProcessor> gp = make_gp();
if (!gp) {
SkDebugf("Couldn't create GrGeometryProcessor\n");
return;
diff --git a/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp b/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp
index 10053fe..284556b 100644
--- a/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp
+++ b/src/gpu/ops/GrNonAAFillRectPerspectiveOp.cpp
@@ -27,14 +27,11 @@
The vertex attrib order is always pos, color, [local coords].
*/
static sk_sp<GrGeometryProcessor> make_persp_gp(const SkMatrix& viewMatrix,
- bool readsCoverage,
bool hasExplicitLocalCoords,
const SkMatrix* localMatrix) {
SkASSERT(viewMatrix.hasPerspective() || (localMatrix && localMatrix->hasPerspective()));
using namespace GrDefaultGeoProcFactory;
- Color color(Color::kAttribute_Type);
- Coverage coverage(readsCoverage ? Coverage::kSolid_Type : Coverage::kNone_Type);
// If we have perspective on the viewMatrix then we won't map on the CPU, nor will we map
// the local rect on the cpu (in case the localMatrix also has perspective).
@@ -44,14 +41,16 @@
LocalCoords localCoords(hasExplicitLocalCoords ? LocalCoords::kHasExplicit_Type
: LocalCoords::kUsePosition_Type,
localMatrix);
- return GrDefaultGeoProcFactory::Make(color, coverage, localCoords, viewMatrix);
+ return GrDefaultGeoProcFactory::Make(Color::kAttribute_Type, Coverage::kSolid_Type,
+ localCoords, viewMatrix);
} else if (hasExplicitLocalCoords) {
LocalCoords localCoords(LocalCoords::kHasExplicit_Type, localMatrix);
- return GrDefaultGeoProcFactory::Make(color, coverage, localCoords, SkMatrix::I());
+ return GrDefaultGeoProcFactory::Make(Color::kAttribute_Type, Coverage::kSolid_Type,
+ localCoords, SkMatrix::I());
} else {
LocalCoords localCoords(LocalCoords::kUsePosition_Type, localMatrix);
- return GrDefaultGeoProcFactory::MakeForDeviceSpace(color, coverage, localCoords,
- viewMatrix);
+ return GrDefaultGeoProcFactory::MakeForDeviceSpace(
+ Color::kAttribute_Type, Coverage::kSolid_Type, localCoords, viewMatrix);
}
}
@@ -142,7 +141,6 @@
void onPrepareDraws(Target* target) const override {
sk_sp<GrGeometryProcessor> gp = make_persp_gp(fViewMatrix,
- fOptimizations.readsCoverage(),
fHasLocalRect,
fHasLocalMatrix ? &fLocalMatrix : nullptr);
if (!gp) {
diff --git a/src/gpu/ops/GrNonAAStrokeRectOp.cpp b/src/gpu/ops/GrNonAAStrokeRectOp.cpp
index 3f63a91..0732e4e 100644
--- a/src/gpu/ops/GrNonAAStrokeRectOp.cpp
+++ b/src/gpu/ops/GrNonAAStrokeRectOp.cpp
@@ -111,12 +111,11 @@
{
using namespace GrDefaultGeoProcFactory;
Color color(fColor);
- Coverage coverage(fOptimizations.readsCoverage() ? Coverage::kSolid_Type
- : Coverage::kNone_Type);
- LocalCoords localCoords(fOptimizations.readsLocalCoords()
- ? LocalCoords::kUsePosition_Type
- : LocalCoords::kUnused_Type);
- gp = GrDefaultGeoProcFactory::Make(color, coverage, localCoords, fViewMatrix);
+ LocalCoords::Type localCoordsType = fOptimizations.readsLocalCoords()
+ ? LocalCoords::kUsePosition_Type
+ : LocalCoords::kUnused_Type;
+ gp = GrDefaultGeoProcFactory::Make(color, Coverage::kSolid_Type, localCoordsType,
+ fViewMatrix);
}
size_t vertexStride = gp->getVertexStride();
diff --git a/src/gpu/ops/GrOvalOpFactory.cpp b/src/gpu/ops/GrOvalOpFactory.cpp
index a014020..51db035 100644
--- a/src/gpu/ops/GrOvalOpFactory.cpp
+++ b/src/gpu/ops/GrOvalOpFactory.cpp
@@ -1251,7 +1251,7 @@
}
void applyPipelineOptimizations(const GrPipelineOptimizations& optimizations) override {
- if (!optimizations.readsCoverage()) {
+ if (!optimizations.readsColor()) {
fGeoData[0].fColor = GrColor_ILLEGAL;
}
if (!optimizations.readsLocalCoords()) {
diff --git a/src/gpu/ops/GrRegionOp.cpp b/src/gpu/ops/GrRegionOp.cpp
index 7fbdd75..ea0af73 100644
--- a/src/gpu/ops/GrRegionOp.cpp
+++ b/src/gpu/ops/GrRegionOp.cpp
@@ -17,13 +17,10 @@
static const int kVertsPerInstance = 4;
static const int kIndicesPerInstance = 6;
-static sk_sp<GrGeometryProcessor> make_gp(bool readsCoverage, const SkMatrix& viewMatrix) {
+static sk_sp<GrGeometryProcessor> make_gp(const SkMatrix& viewMatrix) {
using namespace GrDefaultGeoProcFactory;
- Color color(Color::kAttribute_Type);
- Coverage coverage(readsCoverage ? Coverage::kSolid_Type : Coverage::kNone_Type);
-
- LocalCoords localCoords(LocalCoords::kUsePosition_Type);
- return GrDefaultGeoProcFactory::Make(color, coverage, localCoords, viewMatrix);
+ return GrDefaultGeoProcFactory::Make(Color::kAttribute_Type, Coverage::kSolid_Type,
+ LocalCoords::kUsePosition_Type, viewMatrix);
}
static void tesselate_region(intptr_t vertices,
@@ -91,7 +88,7 @@
}
void onPrepareDraws(Target* target) const override {
- sk_sp<GrGeometryProcessor> gp = make_gp(fOptimizations.readsCoverage(), fViewMatrix);
+ sk_sp<GrGeometryProcessor> gp = make_gp(fViewMatrix);
if (!gp) {
SkDebugf("Couldn't create GrGeometryProcessor\n");
return;
diff --git a/src/gpu/ops/GrTessellatingPathRenderer.cpp b/src/gpu/ops/GrTessellatingPathRenderer.cpp
index 81a982c..afd953e 100644
--- a/src/gpu/ops/GrTessellatingPathRenderer.cpp
+++ b/src/gpu/ops/GrTessellatingPathRenderer.cpp
@@ -278,9 +278,9 @@
using namespace GrDefaultGeoProcFactory;
Color color(fColor);
- LocalCoords localCoords(fOptimizations.readsLocalCoords()
- ? LocalCoords::kUsePosition_Type
- : LocalCoords::kUnused_Type);
+ LocalCoords::Type localCoordsType = fOptimizations.readsLocalCoords()
+ ? LocalCoords::kUsePosition_Type
+ : LocalCoords::kUnused_Type;
Coverage::Type coverageType;
if (fAntiAlias) {
color = Color(Color::kAttribute_Type);
@@ -289,17 +289,15 @@
} else {
coverageType = Coverage::kAttribute_Type;
}
- } else if (fOptimizations.readsCoverage()) {
+ } else {
coverageType = Coverage::kSolid_Type;
- } else {
- coverageType = Coverage::kNone_Type;
}
- Coverage coverage(coverageType);
if (fAntiAlias) {
- gp = GrDefaultGeoProcFactory::MakeForDeviceSpace(color, coverage, localCoords,
- fViewMatrix);
+ gp = GrDefaultGeoProcFactory::MakeForDeviceSpace(color, coverageType,
+ localCoordsType, fViewMatrix);
} else {
- gp = GrDefaultGeoProcFactory::Make(color, coverage, localCoords, fViewMatrix);
+ gp = GrDefaultGeoProcFactory::Make(color, coverageType, localCoordsType,
+ fViewMatrix);
}
}
if (fAntiAlias) {
diff --git a/src/gpu/ops/GrTestMeshDrawOp.h b/src/gpu/ops/GrTestMeshDrawOp.h
index 7fc44e1..8d5a896 100644
--- a/src/gpu/ops/GrTestMeshDrawOp.h
+++ b/src/gpu/ops/GrTestMeshDrawOp.h
@@ -33,7 +33,6 @@
struct Optimizations {
bool fColorIgnored = false;
bool fUsesLocalCoords = false;
- bool fCoverageIgnored = false;
};
const Optimizations optimizations() const { return fOptimizations; }
@@ -49,7 +48,6 @@
fOptimizations.fColorIgnored = !optimizations.readsColor();
fOptimizations.fUsesLocalCoords = optimizations.readsLocalCoords();
- fOptimizations.fCoverageIgnored = !optimizations.readsCoverage();
}
bool onCombineIfPossible(GrOp*, const GrCaps&) override { return false; }