GrSimpleMeshDrawOpHelper Class Reference

#include <GrSimpleMeshDrawOpHelper.h>

Inheritance diagram for GrSimpleMeshDrawOpHelper:

Public Types
enum class	InputFlags : uint8_t { kNone = 0 , kSnapVerticesToPixelCenters = (uint8_t)GrPipeline::InputFlags::kSnapVerticesToPixelCenters , kConservativeRaster = (uint8_t)GrPipeline::InputFlags::kConservativeRaster }

Public Member Functions
	GR_DECL_BITFIELD_CLASS_OPS_FRIENDS (InputFlags)
	GrSimpleMeshDrawOpHelper (GrProcessorSet *, GrAAType, InputFlags=InputFlags::kNone)
	~GrSimpleMeshDrawOpHelper ()
	GrSimpleMeshDrawOpHelper ()=delete
	GrSimpleMeshDrawOpHelper (const GrSimpleMeshDrawOpHelper &)=delete
GrSimpleMeshDrawOpHelper &	operator= (const GrSimpleMeshDrawOpHelper &)=delete
GrDrawOp::FixedFunctionFlags	fixedFunctionFlags () const
bool	isCompatible (const GrSimpleMeshDrawOpHelper &that, const GrCaps &, const SkRect &thisBounds, const SkRect &thatBounds, bool ignoreAAType=false) const
GrProcessorSet::Analysis	finalizeProcessors (const GrCaps &caps, const GrAppliedClip *clip, GrClampType clampType, GrProcessorAnalysisCoverage geometryCoverage, GrProcessorAnalysisColor *geometryColor)
GrProcessorSet::Analysis	finalizeProcessors (const GrCaps &, const GrAppliedClip *, GrClampType, GrProcessorAnalysisCoverage geometryCoverage, SkPMColor4f *geometryColor, bool *wideColor)
bool	isTrivial () const
bool	usesLocalCoords () const
bool	compatibleWithCoverageAsAlpha () const
void	visitProxies (const GrVisitProxyFunc &func) const
GrAAType	aaType () const
void	setAAType (GrAAType aaType)
const GrPipeline *	createPipeline (GrOpFlushState *flushState)
const GrPipeline *	createPipeline (const GrCaps *, SkArenaAlloc *, skgpu::Swizzle writeViewSwizzle, GrAppliedClip &&, const GrDstProxyView &)
GrProgramInfo *	createProgramInfo (const GrCaps *, SkArenaAlloc *, const GrSurfaceProxyView &writeView, bool usesMSAASurface, GrAppliedClip &&, const GrDstProxyView &, GrGeometryProcessor *, GrPrimitiveType, GrXferBarrierFlags renderPassXferBarriers, GrLoadOp colorLoadOp)
GrProcessorSet	detachProcessorSet ()
GrPipeline::InputFlags	pipelineFlags () const
template<typename Op , typename... OpArgs>
GrOp::Owner	FactoryHelper (GrRecordingContext *context, GrPaint &&paint, OpArgs &&... opArgs)

Static Public Member Functions
template<typename Op , typename... OpArgs>
static GrOp::Owner	FactoryHelper (GrRecordingContext *, GrPaint &&, OpArgs &&...)
static const GrPipeline *	CreatePipeline (const GrCaps *, SkArenaAlloc *, skgpu::Swizzle writeViewSwizzle, GrAppliedClip &&, const GrDstProxyView &, GrProcessorSet &&, GrPipeline::InputFlags pipelineFlags)
static const GrPipeline *	CreatePipeline (GrOpFlushState *, GrProcessorSet &&, GrPipeline::InputFlags pipelineFlags)
static GrProgramInfo *	CreateProgramInfo (const GrCaps *, SkArenaAlloc *, const GrPipeline *, const GrSurfaceProxyView &writeView, bool usesMSAASurface, GrGeometryProcessor *, GrPrimitiveType, GrXferBarrierFlags renderPassXferBarriers, GrLoadOp colorLoadOp, const GrUserStencilSettings *=&GrUserStencilSettings::kUnused)
static GrProgramInfo *	CreateProgramInfo (const GrCaps *, SkArenaAlloc *, const GrSurfaceProxyView &writeView, bool usesMSAASurface, GrAppliedClip &&, const GrDstProxyView &, GrGeometryProcessor *, GrProcessorSet &&, GrPrimitiveType, GrXferBarrierFlags renderPassXferBarriers, GrLoadOp colorLoadOp, GrPipeline::InputFlags pipelineFlags=GrPipeline::InputFlags::kNone, const GrUserStencilSettings *=&GrUserStencilSettings::kUnused)

Protected Member Functions
GrProcessorSet::Analysis	finalizeProcessors (const GrCaps &caps, const GrAppliedClip *, const GrUserStencilSettings *, GrClampType, GrProcessorAnalysisCoverage geometryCoverage, GrProcessorAnalysisColor *geometryColor)

Protected Attributes
GrProcessorSet *	fProcessors
GrPipeline::InputFlags	fPipelineFlags
unsigned	fAAType: 2
unsigned	fUsesLocalCoords: 1
unsigned	fCompatibleWithCoverageAsAlpha: 1

Detailed Description

This class can be used to help implement simple mesh draw ops. It reduces the amount of boilerplate code to type and also provides a mechanism for optionally allocating space for a GrProcessorSet based on a GrPaint. It is intended to be used by ops that construct a single GrPipeline for a uniform primitive color and a GrPaint.

Definition at line 28 of file GrSimpleMeshDrawOpHelper.h.

Member Enumeration Documentation

InputFlags

enum class GrSimpleMeshDrawOpHelper::InputFlags : uint8_t

strong

Enumerator
kNone
kSnapVerticesToPixelCenters
kConservativeRaster

Definition at line 40 of file GrSimpleMeshDrawOpHelper.h.

                          : uint8_t {
        kNone = 0,
        kSnapVerticesToPixelCenters = (uint8_t)GrPipeline::InputFlags::kSnapVerticesToPixelCenters,
        kConservativeRaster = (uint8_t)GrPipeline::InputFlags::kConservativeRaster,
    };

Constructor & Destructor Documentation

GrSimpleMeshDrawOpHelper() [1/3]

GrSimpleMeshDrawOpHelper::GrSimpleMeshDrawOpHelper	(	GrProcessorSet *	processorSet,
		GrAAType	aaType,
		InputFlags	inputFlags = InputFlags::kNone
	)

Definition at line 17 of file GrSimpleMeshDrawOpHelper.cpp.

        : fProcessors(processorSet)
        , fPipelineFlags((GrPipeline::InputFlags)inputFlags)
        , fAAType((int)aaType)
        , fUsesLocalCoords(false)
        , fCompatibleWithCoverageAsAlpha(false) {
    SkDEBUGCODE(fDidAnalysis = false);
    SkDEBUGCODE(fMadePipeline = false);
}

~GrSimpleMeshDrawOpHelper()

GrSimpleMeshDrawOpHelper::~GrSimpleMeshDrawOpHelper

(

)

Definition at line 29 of file GrSimpleMeshDrawOpHelper.cpp.

                                                    {
    if (fProcessors) {
        fProcessors->~GrProcessorSet();
    }
}

GrSimpleMeshDrawOpHelper() [2/3]

GrSimpleMeshDrawOpHelper::GrSimpleMeshDrawOpHelper ( )

delete

GrSimpleMeshDrawOpHelper() [3/3]

GrSimpleMeshDrawOpHelper::GrSimpleMeshDrawOpHelper ( const GrSimpleMeshDrawOpHelper &  )

delete

Member Function Documentation

aaType()

GrAAType GrSimpleMeshDrawOpHelper::aaType ( ) const

inline

Definition at line 107 of file GrSimpleMeshDrawOpHelper.h.

{ return static_cast<GrAAType>(fAAType); }

compatibleWithCoverageAsAlpha()

bool GrSimpleMeshDrawOpHelper::compatibleWithCoverageAsAlpha ( ) const

inline

Definition at line 96 of file GrSimpleMeshDrawOpHelper.h.

{ return fCompatibleWithCoverageAsAlpha; }

createPipeline() [1/2]

const GrPipeline * GrSimpleMeshDrawOpHelper::createPipeline	(	const GrCaps *	caps,
		SkArenaAlloc *	arena,
		skgpu::Swizzle	writeViewSwizzle,
		GrAppliedClip &&	appliedClip,
		const GrDstProxyView &	dstProxyView
	)

Definition at line 148 of file GrSimpleMeshDrawOpHelper.cpp.

                                                                                               {
    return GrSimpleMeshDrawOpHelper::CreatePipeline(caps,
                                                    arena,
                                                    writeViewSwizzle,
                                                    std::move(appliedClip),
                                                    dstProxyView,
                                                    this->detachProcessorSet(),
                                                    this->pipelineFlags());
}

CreatePipeline() [1/2]

const GrPipeline * GrSimpleMeshDrawOpHelper::CreatePipeline ( const GrCaps *  caps, SkArenaAlloc *  arena, skgpu::Swizzle  writeViewSwizzle, GrAppliedClip &&  appliedClip, const GrDstProxyView &  dstProxyView, GrProcessorSet &&  processorSet, GrPipeline::InputFlags  pipelineFlags  )

static

Definition at line 107 of file GrSimpleMeshDrawOpHelper.cpp.

                                                                                               {
    GrPipeline::InitArgs pipelineArgs;
 
    pipelineArgs.fInputFlags = pipelineFlags;
    pipelineArgs.fCaps = caps;
    pipelineArgs.fDstProxyView = dstProxyView;
    pipelineArgs.fWriteSwizzle = writeViewSwizzle;
 
    return arena->make<GrPipeline>(pipelineArgs,
                                   std::move(processorSet),
                                   std::move(appliedClip));
}

CreatePipeline() [2/2]

const GrPipeline * GrSimpleMeshDrawOpHelper::CreatePipeline ( GrOpFlushState *  flushState, GrProcessorSet &&  processorSet, GrPipeline::InputFlags  pipelineFlags  )

static

Definition at line 126 of file GrSimpleMeshDrawOpHelper.cpp.

                                                                                               {
    return CreatePipeline(&flushState->caps(),
                          flushState->allocator(),
                          flushState->writeView().swizzle(),
                          flushState->detachAppliedClip(),
                          flushState->dstProxyView(),
                          std::move(processorSet),
                          pipelineFlags);
}

createPipeline() [2/2]

const GrPipeline * GrSimpleMeshDrawOpHelper::createPipeline

(

GrOpFlushState *

flushState

)

Definition at line 138 of file GrSimpleMeshDrawOpHelper.cpp.

                                                                                     {
    return CreatePipeline(&flushState->caps(),
                          flushState->allocator(),
                          flushState->writeView().swizzle(),
                          flushState->detachAppliedClip(),
                          flushState->dstProxyView(),
                          this->detachProcessorSet(),
                          this->pipelineFlags());
}

CreateProgramInfo() [1/2]

GrProgramInfo * GrSimpleMeshDrawOpHelper::CreateProgramInfo ( const GrCaps *  caps, SkArenaAlloc *  arena, const GrPipeline *  pipeline, const GrSurfaceProxyView &  writeView, bool  usesMSAASurface, GrGeometryProcessor *  geometryProcessor, GrPrimitiveType  primitiveType, GrXferBarrierFlags  renderPassXferBarriers, GrLoadOp  colorLoadOp, const GrUserStencilSettings *  stencilSettings = &GrUserStencilSettings::kUnused  )

static

Definition at line 188 of file GrSimpleMeshDrawOpHelper.cpp.

                                                                                                         {
    auto tmp = arena->make<GrProgramInfo>(*caps,
                                          writeView,
                                          usesMSAASurface,
                                          pipeline,
                                          stencilSettings,
                                          geometryProcessor,
                                          primitiveType,
                                          xferBarrierFlags,
                                          colorLoadOp);
    return tmp;
}

createProgramInfo()

GrProgramInfo * GrSimpleMeshDrawOpHelper::createProgramInfo	(	const GrCaps *	caps,
		SkArenaAlloc *	arena,
		const GrSurfaceProxyView &	writeView,
		bool	usesMSAASurface,
		GrAppliedClip &&	appliedClip,
		const GrDstProxyView &	dstProxyView,
		GrGeometryProcessor *	gp,
		GrPrimitiveType	primType,
		GrXferBarrierFlags	renderPassXferBarriers,
		GrLoadOp	colorLoadOp
	)

Definition at line 210 of file GrSimpleMeshDrawOpHelper.cpp.

                                                                  {
    return CreateProgramInfo(caps,
                             arena,
                             writeView,
                             usesMSAASurface,
                             std::move(appliedClip),
                             dstProxyView,
                             gp,
                             this->detachProcessorSet(),
                             primType,
                             renderPassXferBarriers,
                             colorLoadOp,
                             this->pipelineFlags());
}

CreateProgramInfo() [2/2]

GrProgramInfo * GrSimpleMeshDrawOpHelper::CreateProgramInfo ( const GrCaps *  caps, SkArenaAlloc *  arena, const GrSurfaceProxyView &  writeView, bool  usesMSAASurface, GrAppliedClip &&  appliedClip, const GrDstProxyView &  dstProxyView, GrGeometryProcessor *  geometryProcessor, GrProcessorSet &&  processorSet, GrPrimitiveType  primitiveType, GrXferBarrierFlags  renderPassXferBarriers, GrLoadOp  colorLoadOp, GrPipeline::InputFlags  pipelineFlags = GrPipeline::InputFlags::kNone, const GrUserStencilSettings *  stencilSettings = &GrUserStencilSettings::kUnused  )

static

Definition at line 162 of file GrSimpleMeshDrawOpHelper.cpp.

                                                          {
    auto pipeline = CreatePipeline(caps,
                                   arena,
                                   writeView.swizzle(),
                                   std::move(appliedClip),
                                   dstProxyView,
                                   std::move(processorSet),
                                   pipelineFlags);
 
    return CreateProgramInfo(caps, arena, pipeline, writeView, usesMSAASurface, geometryProcessor,
                             primitiveType, renderPassXferBarriers, colorLoadOp, stencilSettings);
}

detachProcessorSet()

GrProcessorSet GrSimpleMeshDrawOpHelper::detachProcessorSet ( )

inline

Definition at line 175 of file GrSimpleMeshDrawOpHelper.h.

                                        {
        return fProcessors ? std::move(*fProcessors) : GrProcessorSet::MakeEmptySet();
    }

FactoryHelper() [1/2]

template<typename Op , typename... OpArgs>

static GrOp::Owner GrSimpleMeshDrawOpHelper::FactoryHelper ( GrRecordingContext *  , GrPaint &&  , OpArgs &&  ...  )

static

This can be used by a Op class to perform allocation and initialization such that a GrProcessorSet (if required) is allocated as part of the the same allocation that as the Op instance. It requires that Op implements a constructor of the form: Op(ProcessorSet*, GrColor, OpArgs...).

FactoryHelper() [2/2]

template<typename Op , typename... OpArgs>

GrOp::Owner GrSimpleMeshDrawOpHelper::FactoryHelper	(	GrRecordingContext *	context,
		GrPaint &&	paint,
		OpArgs &&...	opArgs
	)

Definition at line 207 of file GrSimpleMeshDrawOpHelper.h.

                                                                         {
    auto color = paint.getColor4f();
    if (paint.isTrivial()) {
        return GrOp::Make<Op>(context, nullptr, color, std::forward<OpArgs>(opArgs)...);
    } else {
        return GrOp::MakeWithProcessorSet<Op>(
                context, color, std::move(paint), std::forward<OpArgs>(opArgs)...);
    }
}

finalizeProcessors() [1/3]

GrProcessorSet::Analysis GrSimpleMeshDrawOpHelper::finalizeProcessors	(	const GrCaps &	caps,
		const GrAppliedClip *	clip,
		GrClampType	clampType,
		GrProcessorAnalysisCoverage	geometryCoverage,
		SkPMColor4f *	geometryColor,
		bool *	wideColor
	)

Version of above that can be used by ops that have a constant color geometry processor output. The op passes this color as 'geometryColor' and after return if 'geometryColor' has changed the op must override its geometry processor color output with the new color.

Definition at line 68 of file GrSimpleMeshDrawOpHelper.cpp.

                                                                                                   {
    GrProcessorAnalysisColor color = *geometryColor;
    auto result = this->finalizeProcessors(caps, clip, clampType, geometryCoverage, &color);
    color.isConstant(geometryColor);
    if (wideColor) {
        *wideColor = !geometryColor->fitsInBytes();
    }
    return result;
}

finalizeProcessors() [2/3]

GrProcessorSet::Analysis GrSimpleMeshDrawOpHelper::finalizeProcessors ( const GrCaps &  caps, const GrAppliedClip *  clip, const GrUserStencilSettings *  userStencil, GrClampType  clampType, GrProcessorAnalysisCoverage  geometryCoverage, GrProcessorAnalysisColor *  geometryColor  )

protected

Definition at line 80 of file GrSimpleMeshDrawOpHelper.cpp.

                                                 {
    SkDEBUGCODE(fDidAnalysis = true);
    GrProcessorSet::Analysis analysis;
    if (fProcessors) {
        GrProcessorAnalysisCoverage coverage = geometryCoverage;
        if (GrProcessorAnalysisCoverage::kNone == coverage) {
            coverage = (clip && clip->hasCoverageFragmentProcessor())
                               ? GrProcessorAnalysisCoverage::kSingleChannel
                               : GrProcessorAnalysisCoverage::kNone;
        }
        SkPMColor4f overrideColor;
        analysis = fProcessors->finalize(*geometryColor, coverage, clip, userStencil, caps,
                                         clampType, &overrideColor);
        if (analysis.inputColorIsOverridden()) {
            *geometryColor = overrideColor;
        }
    } else {
        analysis = GrProcessorSet::EmptySetAnalysis();
    }
    fUsesLocalCoords = analysis.usesLocalCoords();
    fCompatibleWithCoverageAsAlpha = analysis.isCompatibleWithCoverageAsAlpha();
    return analysis;
}

finalizeProcessors() [3/3]

GrProcessorSet::Analysis GrSimpleMeshDrawOpHelper::finalizeProcessors ( const GrCaps &  caps, const GrAppliedClip *  clip, GrClampType  clampType, GrProcessorAnalysisCoverage  geometryCoverage, GrProcessorAnalysisColor *  geometryColor  )

inline

Finalizes the processor set and determines whether the destination must be provided to the fragment shader as a texture for blending.

Parameters

geometryCoverage	Describes the coverage output of the op's geometry processor
geometryColor	An in/out param. As input this informs processor analysis about the color the op expects to output from its geometry processor. As output this may be set to a known color in which case the op must output this color from its geometry processor instead.

Definition at line 70 of file GrSimpleMeshDrawOpHelper.h.

                                                                                         {
        return this->finalizeProcessors(caps, clip, &GrUserStencilSettings::kUnused, clampType,
                                        geometryCoverage, geometryColor);
    }

fixedFunctionFlags()

GrDrawOp::FixedFunctionFlags GrSimpleMeshDrawOpHelper::fixedFunctionFlags

(

)

const

Definition at line 35 of file GrSimpleMeshDrawOpHelper.cpp.

                                                                              {
    return GrAATypeIsHW(this->aaType()) ? GrDrawOp::FixedFunctionFlags::kUsesHWAA
                                        : GrDrawOp::FixedFunctionFlags::kNone;
}

GR_DECL_BITFIELD_CLASS_OPS_FRIENDS()

GrSimpleMeshDrawOpHelper::GR_DECL_BITFIELD_CLASS_OPS_FRIENDS

(

InputFlags

)

isCompatible()

bool GrSimpleMeshDrawOpHelper::isCompatible	(	const GrSimpleMeshDrawOpHelper &	that,
		const GrCaps &	caps,
		const SkRect &	thisBounds,
		const SkRect &	thatBounds,
		bool	ignoreAAType = false
	)		const

Definition at line 40 of file GrSimpleMeshDrawOpHelper.cpp.

                                                                                               {
    if (SkToBool(fProcessors) != SkToBool(that.fProcessors)) {
        return false;
    }
    if (fProcessors) {
        if (*fProcessors != *that.fProcessors) {
            return false;
        }
    }
 
#ifdef SK_DEBUG
    if (ignoreAAType) {
        // If we're ignoring AA it should be bc we already know they are the same or that
        // the are different but are compatible (i.e., one is AA and the other is None)
        SkASSERT(fAAType == that.fAAType ||
                 GrMeshDrawOp::CanUpgradeAAOnMerge(this->aaType(), that.aaType()));
    }
#endif
 
    bool result = fPipelineFlags == that.fPipelineFlags &&
                  (ignoreAAType || fAAType == that.fAAType);
    SkASSERT(!result || fCompatibleWithCoverageAsAlpha == that.fCompatibleWithCoverageAsAlpha);
    SkASSERT(!result || fUsesLocalCoords == that.fUsesLocalCoords);
    return result;
}

isTrivial()

bool GrSimpleMeshDrawOpHelper::isTrivial ( ) const

inline

Definition at line 87 of file GrSimpleMeshDrawOpHelper.h.

                           {
      return fProcessors == nullptr;
    }

operator=()

GrSimpleMeshDrawOpHelper & GrSimpleMeshDrawOpHelper::operator= ( const GrSimpleMeshDrawOpHelper &  )

delete

pipelineFlags()

GrPipeline::InputFlags GrSimpleMeshDrawOpHelper::pipelineFlags ( ) const

inline

Definition at line 179 of file GrSimpleMeshDrawOpHelper.h.

{ return fPipelineFlags; }

setAAType()

void GrSimpleMeshDrawOpHelper::setAAType ( GrAAType  aaType )

inline

Definition at line 109 of file GrSimpleMeshDrawOpHelper.h.

                                    {
        fAAType = static_cast<unsigned>(aaType);
    }

usesLocalCoords()

bool GrSimpleMeshDrawOpHelper::usesLocalCoords ( ) const

inline

Definition at line 91 of file GrSimpleMeshDrawOpHelper.h.

                                 {
        SkASSERT(fDidAnalysis);
        return fUsesLocalCoords;
    }

visitProxies()

void GrSimpleMeshDrawOpHelper::visitProxies ( const GrVisitProxyFunc &  func ) const

inline

Definition at line 98 of file GrSimpleMeshDrawOpHelper.h.

                                                          {
        if (fProcessors) {
            fProcessors->visitProxies(func);
        }
    }

Member Data Documentation

fAAType

unsigned GrSimpleMeshDrawOpHelper::fAAType

protected

Definition at line 189 of file GrSimpleMeshDrawOpHelper.h.

fCompatibleWithCoverageAsAlpha

unsigned GrSimpleMeshDrawOpHelper::fCompatibleWithCoverageAsAlpha

protected

Definition at line 191 of file GrSimpleMeshDrawOpHelper.h.

fPipelineFlags

GrPipeline::InputFlags GrSimpleMeshDrawOpHelper::fPipelineFlags

protected

Definition at line 188 of file GrSimpleMeshDrawOpHelper.h.

fProcessors

GrProcessorSet* GrSimpleMeshDrawOpHelper::fProcessors

protected

Definition at line 187 of file GrSimpleMeshDrawOpHelper.h.

fUsesLocalCoords

unsigned GrSimpleMeshDrawOpHelper::fUsesLocalCoords

protected

Definition at line 190 of file GrSimpleMeshDrawOpHelper.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/src/gpu/ganesh/ops/GrSimpleMeshDrawOpHelper.h
• third_party/skia/src/gpu/ganesh/ops/GrSimpleMeshDrawOpHelper.cpp