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/gm/samplelocations.cpp b/gm/samplelocations.cpp index d103483..a9a787a 100644 --- a/gm/samplelocations.cpp +++ b/gm/samplelocations.cpp
@@ -191,7 +191,8 @@ ); GrPipeline pipeline(GrScissorTest::kDisabled, SkBlendMode::kSrcOver, - GrPipeline::Flags::kHWAntialias_Flag, &kStencilWrite); + GrPipeline::InputFlags::kHWAntialias, &kStencilWrite); + GrMesh mesh(GrPrimitiveType::kTriangleStrip); mesh.setInstanced(nullptr, 200*200, 0, 4); flushState->rtCommandBuffer()->draw(
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); }