Rename GrPipeline::Flags to GrPipeline::InputFlags
Renames the Flags to InputFlags and makes it a strongly typed enum.
Simplifies the relationship between GrSimpleMeshDrawOpHelper::Flags
and GrPipeline::InputFlags.
Bug: skia:
Change-Id: Ia25b8526ff96a47428dfbb82da18dbebdd382c5b
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/204906
Commit-Queue: Chris Dalton <csmartdalton@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>
diff --git a/src/gpu/GrOpFlushState.cpp b/src/gpu/GrOpFlushState.cpp
index 3b59782..0b0d9ba 100644
--- a/src/gpu/GrOpFlushState.cpp
+++ b/src/gpu/GrOpFlushState.cpp
@@ -35,11 +35,11 @@
void GrOpFlushState::executeDrawsAndUploadsForMeshDrawOp(
const GrOp* op, const SkRect& chainBounds, GrProcessorSet&& processorSet,
- uint32_t pipelineFlags, const GrUserStencilSettings* stencilSettings) {
+ GrPipeline::InputFlags pipelineFlags, const GrUserStencilSettings* stencilSettings) {
SkASSERT(this->rtCommandBuffer());
GrPipeline::InitArgs pipelineArgs;
- pipelineArgs.fFlags = pipelineFlags;
+ pipelineArgs.fInputFlags = pipelineFlags;
pipelineArgs.fDstProxy = this->dstProxy();
pipelineArgs.fCaps = &this->caps();
pipelineArgs.fResourceProvider = this->resourceProvider();
diff --git a/src/gpu/GrOpFlushState.h b/src/gpu/GrOpFlushState.h
index 3016061..66aa470 100644
--- a/src/gpu/GrOpFlushState.h
+++ b/src/gpu/GrOpFlushState.h
@@ -42,7 +42,8 @@
/** Called as ops are executed. Must be called in the same order as the ops were prepared. */
void executeDrawsAndUploadsForMeshDrawOp(
- const GrOp* op, const SkRect& chainBounds, GrProcessorSet&&, uint32_t pipelineFlags = 0,
+ const GrOp* op, const SkRect& chainBounds, GrProcessorSet&&,
+ GrPipeline::InputFlags = GrPipeline::InputFlags::kNone,
const GrUserStencilSettings* = &GrUserStencilSettings::kUnused);
GrGpuCommandBuffer* commandBuffer() { return fCommandBuffer; }
diff --git a/src/gpu/GrPipeline.cpp b/src/gpu/GrPipeline.cpp
index 504d438..2c15f32 100644
--- a/src/gpu/GrPipeline.cpp
+++ b/src/gpu/GrPipeline.cpp
@@ -21,17 +21,17 @@
GrAppliedClip&& appliedClip) {
SkASSERT(processors.isFinalized());
- fFlags = args.fFlags;
+ fFlags = (Flags)args.fInputFlags;
if (appliedClip.hasStencilClip()) {
- fFlags |= kHasStencilClip_Flag;
+ fFlags |= Flags::kHasStencilClip;
}
if (appliedClip.scissorState().enabled()) {
- fFlags |= kScissorEnabled_Flag;
+ fFlags |= Flags::kScissorEnabled;
}
fWindowRectsState = appliedClip.windowRectsState();
- if (!args.fUserStencil->isDisabled(fFlags & kHasStencilClip_Flag)) {
- fFlags |= kStencilEnabled_Flag;
+ if (!args.fUserStencil->isDisabled(fFlags & Flags::kHasStencilClip)) {
+ fFlags |= Flags::kStencilEnabled;
}
fUserStencilSettings = args.fUserStencil;
@@ -97,19 +97,19 @@
return this->getXferProcessor().xferBarrierType(caps);
}
-GrPipeline::GrPipeline(GrScissorTest scissorTest, SkBlendMode blendmode, uint32_t flags,
+GrPipeline::GrPipeline(GrScissorTest scissorTest, SkBlendMode blendmode, InputFlags inputFlags,
const GrUserStencilSettings* userStencil)
: fWindowRectsState()
, fUserStencilSettings(userStencil)
- , fFlags(flags)
+ , fFlags((Flags)inputFlags)
, fXferProcessor(GrPorterDuffXPFactory::MakeNoCoverageXP(blendmode))
, fFragmentProcessors()
, fNumColorProcessors(0) {
if (GrScissorTest::kEnabled == scissorTest) {
- fFlags |= kScissorEnabled_Flag;
+ fFlags |= Flags::kScissorEnabled;
}
if (!userStencil->isDisabled(false)) {
- fFlags |= kStencilEnabled_Flag;
+ fFlags |= Flags::kStencilEnabled;
}
}
diff --git a/src/gpu/GrPipeline.h b/src/gpu/GrPipeline.h
index a131753..9bef15b 100644
--- a/src/gpu/GrPipeline.h
+++ b/src/gpu/GrPipeline.h
@@ -39,21 +39,24 @@
///////////////////////////////////////////////////////////////////////////
/// @name Creation
- enum Flags {
+ // Pipeline options that the caller may enable.
+ // NOTE: This enum is extended later by GrPipeline::Flags.
+ enum class InputFlags : uint8_t {
+ kNone = 0,
/**
* Perform HW anti-aliasing. This means either HW FSAA, if supported by the render target,
* or smooth-line rendering if a line primitive is drawn and line smoothing is supported by
* the 3D API.
*/
- kHWAntialias_Flag = 0x1,
+ kHWAntialias = (1 << 0),
/**
* Modifies the vertex shader so that vertices will be positioned at pixel centers.
*/
- kSnapVerticesToPixelCenters_Flag = 0x2,
+ kSnapVerticesToPixelCenters = (1 << 1), // This value must be last. (See kLastInputFlag.)
};
struct InitArgs {
- uint32_t fFlags = 0;
+ InputFlags fInputFlags = InputFlags::kNone;
const GrUserStencilSettings* fUserStencil = &GrUserStencilSettings::kUnused;
const GrCaps* fCaps = nullptr;
GrResourceProvider* fResourceProvider = nullptr;
@@ -93,7 +96,7 @@
* must be "Porter Duff" (<= kLastCoeffMode). If using GrScissorTest::kEnabled, the caller must
* specify a scissor rectangle through the DynamicState struct.
**/
- GrPipeline(GrScissorTest, SkBlendMode, uint32_t flags = 0,
+ GrPipeline(GrScissorTest, SkBlendMode, InputFlags = InputFlags::kNone,
const GrUserStencilSettings* = &GrUserStencilSettings::kUnused);
GrPipeline(const InitArgs&, GrProcessorSet&&, GrAppliedClip&&);
@@ -163,53 +166,45 @@
const GrUserStencilSettings* getUserStencil() const { return fUserStencilSettings; }
bool isScissorEnabled() const {
- return SkToBool(fFlags & kScissorEnabled_Flag);
+ return SkToBool(fFlags & Flags::kScissorEnabled);
}
const GrWindowRectsState& getWindowRectsState() const { return fWindowRectsState; }
- bool isHWAntialiasState() const { return SkToBool(fFlags & kHWAntialias_Flag); }
+ bool isHWAntialiasState() const { return SkToBool(fFlags & InputFlags::kHWAntialias); }
bool snapVerticesToPixelCenters() const {
- return SkToBool(fFlags & kSnapVerticesToPixelCenters_Flag);
+ return SkToBool(fFlags & InputFlags::kSnapVerticesToPixelCenters);
}
bool hasStencilClip() const {
- return SkToBool(fFlags & kHasStencilClip_Flag);
+ return SkToBool(fFlags & Flags::kHasStencilClip);
}
bool isStencilEnabled() const {
- return SkToBool(fFlags & kStencilEnabled_Flag);
+ return SkToBool(fFlags & Flags::kStencilEnabled);
}
- bool isBad() const { return SkToBool(fFlags & kIsBad_Flag); }
+ bool isBad() const { return SkToBool(fFlags & Flags::kIsBad); }
GrXferBarrierType xferBarrierType(GrTexture*, const GrCaps&) const;
- static SkString DumpFlags(uint32_t flags) {
- if (flags) {
- SkString result;
- if (flags & GrPipeline::kSnapVerticesToPixelCenters_Flag) {
- result.append("Snap vertices to pixel center.\n");
- }
- if (flags & GrPipeline::kHWAntialias_Flag) {
- result.append("HW Antialiasing enabled.\n");
- }
- return result;
- }
- return SkString("No pipeline flags\n");
- }
-
// Used by Vulkan and Metal to cache their respective pipeline objects
uint32_t getBlendInfoKey() const;
private:
- void markAsBad() { fFlags |= kIsBad_Flag; }
+ void markAsBad() { fFlags |= Flags::kIsBad; }
- /** This is a continuation of the public "Flags" enum. */
- enum PrivateFlags {
- kHasStencilClip_Flag = 0x10,
- kStencilEnabled_Flag = 0x20,
- kScissorEnabled_Flag = 0x40,
- kIsBad_Flag = 0x80,
+ static constexpr uint8_t kLastInputFlag = (uint8_t)InputFlags::kSnapVerticesToPixelCenters;
+
+ /** This is a continuation of the public "InputFlags" enum. */
+ enum class Flags : uint8_t {
+ kHasStencilClip = (kLastInputFlag << 1),
+ kStencilEnabled = (kLastInputFlag << 2),
+ kScissorEnabled = (kLastInputFlag << 3),
+ kIsBad = (kLastInputFlag << 4),
};
+ GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(Flags);
+
+ friend bool operator&(Flags, InputFlags);
+
using DstTextureProxy = GrPendingIOResource<GrTextureProxy, kRead_GrIOType>;
using FragmentProcessorArray = SkAutoSTArray<8, std::unique_ptr<const GrFragmentProcessor>>;
@@ -217,7 +212,7 @@
SkIPoint fDstTextureOffset;
GrWindowRectsState fWindowRectsState;
const GrUserStencilSettings* fUserStencilSettings;
- uint16_t fFlags;
+ Flags fFlags;
sk_sp<const GrXferProcessor> fXferProcessor;
FragmentProcessorArray fFragmentProcessors;
@@ -225,4 +220,11 @@
int fNumColorProcessors;
};
+GR_MAKE_BITFIELD_CLASS_OPS(GrPipeline::InputFlags);
+GR_MAKE_BITFIELD_CLASS_OPS(GrPipeline::Flags);
+
+inline bool operator&(GrPipeline::Flags flags, GrPipeline::InputFlags inputFlag) {
+ return (flags & (GrPipeline::Flags)inputFlag);
+}
+
#endif
diff --git a/src/gpu/ops/GrAtlasTextOp.cpp b/src/gpu/ops/GrAtlasTextOp.cpp
index 1826a0b..7588c6c 100644
--- a/src/gpu/ops/GrAtlasTextOp.cpp
+++ b/src/gpu/ops/GrAtlasTextOp.cpp
@@ -390,9 +390,8 @@
}
void GrAtlasTextOp::onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) {
- static const uint32_t kPipelineFlags = 0;
flushState->executeDrawsAndUploadsForMeshDrawOp(
- this, chainBounds, std::move(fProcessors), kPipelineFlags);
+ this, chainBounds, std::move(fProcessors), GrPipeline::InputFlags::kNone);
}
void GrAtlasTextOp::flush(GrMeshDrawOp::Target* target, FlushInfo* flushInfo) const {
diff --git a/src/gpu/ops/GrDashOp.cpp b/src/gpu/ops/GrDashOp.cpp
index 3893ba4..ec5e22e 100644
--- a/src/gpu/ops/GrDashOp.cpp
+++ b/src/gpu/ops/GrDashOp.cpp
@@ -624,9 +624,9 @@
}
void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
- uint32_t pipelineFlags = 0;
+ auto pipelineFlags = GrPipeline::InputFlags::kNone;
if (AAMode::kCoverageWithMSAA == fAAMode) {
- pipelineFlags |= GrPipeline::kHWAntialias_Flag;
+ pipelineFlags |= GrPipeline::InputFlags::kHWAntialias;
}
flushState->executeDrawsAndUploadsForMeshDrawOp(
this, chainBounds, std::move(fProcessorSet), pipelineFlags, fStencilSettings);
diff --git a/src/gpu/ops/GrDrawPathOp.cpp b/src/gpu/ops/GrDrawPathOp.cpp
index ede3bb2..72910a1 100644
--- a/src/gpu/ops/GrDrawPathOp.cpp
+++ b/src/gpu/ops/GrDrawPathOp.cpp
@@ -45,7 +45,7 @@
GrPipeline::InitArgs GrDrawPathOpBase::pipelineInitArgs(const GrOpFlushState& state) {
GrPipeline::InitArgs args;
if (fDoAA) {
- args.fFlags |= GrPipeline::kHWAntialias_Flag;
+ args.fInputFlags |= GrPipeline::InputFlags::kHWAntialias;
}
args.fUserStencil = &kCoverPass;
args.fCaps = &state.caps();
diff --git a/src/gpu/ops/GrFillRRectOp.cpp b/src/gpu/ops/GrFillRRectOp.cpp
index 12d4300..a302099 100644
--- a/src/gpu/ops/GrFillRRectOp.cpp
+++ b/src/gpu/ops/GrFillRRectOp.cpp
@@ -741,7 +741,7 @@
GrPipeline::InitArgs initArgs;
if (GrAAType::kMSAA == fAAType) {
- initArgs.fFlags = GrPipeline::kHWAntialias_Flag;
+ initArgs.fInputFlags = GrPipeline::InputFlags::kHWAntialias;
}
initArgs.fCaps = &flushState->caps();
initArgs.fResourceProvider = flushState->resourceProvider();
diff --git a/src/gpu/ops/GrSimpleMeshDrawOpHelper.cpp b/src/gpu/ops/GrSimpleMeshDrawOpHelper.cpp
index 2863870..4826b3e 100644
--- a/src/gpu/ops/GrSimpleMeshDrawOpHelper.cpp
+++ b/src/gpu/ops/GrSimpleMeshDrawOpHelper.cpp
@@ -13,19 +13,16 @@
#include "SkGr.h"
GrSimpleMeshDrawOpHelper::GrSimpleMeshDrawOpHelper(const MakeArgs& args, GrAAType aaType,
- Flags flags)
+ InputFlags inputFlags)
: fProcessors(args.fProcessorSet)
- , fPipelineFlags(0)
+ , fPipelineFlags((GrPipeline::InputFlags)inputFlags)
, fAAType((int)aaType)
, fUsesLocalCoords(false)
, fCompatibleWithCoverageAsAlpha(false) {
SkDEBUGCODE(fDidAnalysis = false);
SkDEBUGCODE(fMadePipeline = false);
if (GrAATypeIsHW(aaType)) {
- fPipelineFlags |= GrPipeline::kHWAntialias_Flag;
- }
- if (flags & Flags::kSnapVerticesToPixelCenters) {
- fPipelineFlags |= GrPipeline::kSnapVerticesToPixelCenters_Flag;
+ fPipelineFlags |= GrPipeline::InputFlags::kHWAntialias;
}
}
@@ -115,6 +112,19 @@
}
#ifdef SK_DEBUG
+static void dump_pipeline_flags(GrPipeline::InputFlags flags, SkString* result) {
+ if (GrPipeline::InputFlags::kNone != flags) {
+ if (flags & GrPipeline::InputFlags::kSnapVerticesToPixelCenters) {
+ result->append("Snap vertices to pixel center.\n");
+ }
+ if (flags & GrPipeline::InputFlags::kHWAntialias) {
+ result->append("HW Antialiasing enabled.\n");
+ }
+ return;
+ }
+ result->append("No pipeline flags\n");
+}
+
SkString GrSimpleMeshDrawOpHelper::dumpInfo() const {
const GrProcessorSet& processors = fProcessors ? *fProcessors : GrProcessorSet::EmptySet();
SkString result = processors.dumpProcessors();
@@ -133,15 +143,15 @@
result.append(" mixed samples\n");
break;
}
- result.append(GrPipeline::DumpFlags(fPipelineFlags));
+ dump_pipeline_flags(fPipelineFlags, &result);
return result;
}
#endif
GrSimpleMeshDrawOpHelperWithStencil::GrSimpleMeshDrawOpHelperWithStencil(
const MakeArgs& args, GrAAType aaType, const GrUserStencilSettings* stencilSettings,
- Flags flags)
- : INHERITED(args, aaType, flags)
+ InputFlags inputFlags)
+ : INHERITED(args, aaType, inputFlags)
, fStencilSettings(stencilSettings ? stencilSettings : &GrUserStencilSettings::kUnused) {}
GrDrawOp::FixedFunctionFlags GrSimpleMeshDrawOpHelperWithStencil::fixedFunctionFlags() const {
diff --git a/src/gpu/ops/GrSimpleMeshDrawOpHelper.h b/src/gpu/ops/GrSimpleMeshDrawOpHelper.h
index b2708ff..fee013f 100644
--- a/src/gpu/ops/GrSimpleMeshDrawOpHelper.h
+++ b/src/gpu/ops/GrSimpleMeshDrawOpHelper.h
@@ -38,13 +38,14 @@
template <typename Op, typename... OpArgs>
static std::unique_ptr<GrDrawOp> FactoryHelper(GrRecordingContext*, GrPaint&&, OpArgs...);
- enum class Flags : uint32_t {
- kNone = 0x0,
- kSnapVerticesToPixelCenters = 0x1,
+ // Here we allow callers to specify a subset of the GrPipeline::InputFlags upon creation.
+ enum class InputFlags : uint8_t {
+ kNone = 0,
+ kSnapVerticesToPixelCenters = (uint8_t)GrPipeline::InputFlags::kSnapVerticesToPixelCenters,
};
- GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(Flags);
+ GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(InputFlags);
- GrSimpleMeshDrawOpHelper(const MakeArgs&, GrAAType, Flags = Flags::kNone);
+ GrSimpleMeshDrawOpHelper(const MakeArgs&, GrAAType, InputFlags = InputFlags::kNone);
~GrSimpleMeshDrawOpHelper();
GrSimpleMeshDrawOpHelper() = delete;
@@ -124,7 +125,7 @@
void executeDrawsAndUploads(const GrOp*, GrOpFlushState*, const SkRect& chainBounds);
protected:
- uint32_t pipelineFlags() const { return fPipelineFlags; }
+ GrPipeline::InputFlags pipelineFlags() const { return fPipelineFlags; }
GrProcessorSet::Analysis finalizeProcessors(
const GrCaps& caps, const GrAppliedClip*, const GrUserStencilSettings*, GrFSAAType,
@@ -132,7 +133,7 @@
GrProcessorAnalysisColor* geometryColor);
GrProcessorSet* fProcessors;
- unsigned fPipelineFlags : 8;
+ GrPipeline::InputFlags fPipelineFlags;
unsigned fAAType : 2;
unsigned fUsesLocalCoords : 1;
unsigned fCompatibleWithCoverageAsAlpha : 1;
@@ -148,7 +149,7 @@
class GrSimpleMeshDrawOpHelperWithStencil : private GrSimpleMeshDrawOpHelper {
public:
using MakeArgs = GrSimpleMeshDrawOpHelper::MakeArgs;
- using Flags = GrSimpleMeshDrawOpHelper::Flags;
+ using InputFlags = GrSimpleMeshDrawOpHelper::InputFlags;
using GrSimpleMeshDrawOpHelper::visitProxies;
@@ -161,7 +162,7 @@
}
GrSimpleMeshDrawOpHelperWithStencil(const MakeArgs&, GrAAType, const GrUserStencilSettings*,
- Flags = Flags::kNone);
+ InputFlags = InputFlags::kNone);
GrDrawOp::FixedFunctionFlags fixedFunctionFlags() const;
@@ -220,6 +221,6 @@
}
}
-GR_MAKE_BITFIELD_CLASS_OPS(GrSimpleMeshDrawOpHelper::Flags)
+GR_MAKE_BITFIELD_CLASS_OPS(GrSimpleMeshDrawOpHelper::InputFlags)
#endif
diff --git a/src/gpu/ops/GrStrokeRectOp.cpp b/src/gpu/ops/GrStrokeRectOp.cpp
index 4aac66d..c7b469c 100644
--- a/src/gpu/ops/GrStrokeRectOp.cpp
+++ b/src/gpu/ops/GrStrokeRectOp.cpp
@@ -117,22 +117,22 @@
if (!allowed_stroke(stroke, GrAA::kNo, &isMiter)) {
return nullptr;
}
- Helper::Flags flags = Helper::Flags::kNone;
+ Helper::InputFlags inputFlags = Helper::InputFlags::kNone;
// Depending on sub-pixel coordinates and the particular GPU, we may lose a corner of
// hairline rects. We jam all the vertices to pixel centers to avoid this, but not
// when MSAA is enabled because it can cause ugly artifacts.
if (stroke.getStyle() == SkStrokeRec::kHairline_Style && aaType != GrAAType::kMSAA) {
- flags |= Helper::Flags::kSnapVerticesToPixelCenters;
+ inputFlags |= Helper::InputFlags::kSnapVerticesToPixelCenters;
}
- return Helper::FactoryHelper<NonAAStrokeRectOp>(context, std::move(paint), flags,
+ return Helper::FactoryHelper<NonAAStrokeRectOp>(context, std::move(paint), inputFlags,
viewMatrix, rect,
stroke, aaType);
}
NonAAStrokeRectOp(const Helper::MakeArgs& helperArgs, const SkPMColor4f& color,
- Helper::Flags flags, const SkMatrix& viewMatrix, const SkRect& rect,
+ Helper::InputFlags inputFlags, const SkMatrix& viewMatrix, const SkRect& rect,
const SkStrokeRec& stroke, GrAAType aaType)
- : INHERITED(ClassID()), fHelper(helperArgs, aaType, flags) {
+ : INHERITED(ClassID()), fHelper(helperArgs, aaType, inputFlags) {
fColor = color;
fViewMatrix = viewMatrix;
fRect = rect;
@@ -145,7 +145,7 @@
bounds.outset(rad, rad);
// If our caller snaps to pixel centers then we have to round out the bounds
- if (flags & Helper::Flags::kSnapVerticesToPixelCenters) {
+ if (inputFlags & Helper::InputFlags::kSnapVerticesToPixelCenters) {
viewMatrix.mapRect(&bounds);
// We want to be consistent with how we snap non-aa lines. To match what we do in
// GrGLSLVertexShaderBuilder, we first floor all the vertex values and then add half a
diff --git a/src/gpu/ops/GrTextureOp.cpp b/src/gpu/ops/GrTextureOp.cpp
index 6fdeb87..a3a1153 100644
--- a/src/gpu/ops/GrTextureOp.cpp
+++ b/src/gpu/ops/GrTextureOp.cpp
@@ -547,8 +547,8 @@
void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
auto pipelineFlags = (GrAAType::kMSAA == this->aaType())
- ? GrPipeline::kHWAntialias_Flag
- : 0;
+ ? GrPipeline::InputFlags::kHWAntialias
+ : GrPipeline::InputFlags::kNone;
flushState->executeDrawsAndUploadsForMeshDrawOp(
this, chainBounds, GrProcessorSet::MakeEmptySet(), pipelineFlags);
}