#include <GrConvexPolyEffect.h>

Inheritance diagram for GrConvexPolyEffect:

Public Member Functions
	~GrConvexPolyEffect () override

const char *	name () const override

std::unique_ptr< GrFragmentProcessor >	clone () const override

Public Member Functions inherited from GrFragmentProcessor
const GrFragmentProcessor *	parent () const

std::unique_ptr< ProgramImpl >	makeProgramImpl () const

void	addToKey (const GrShaderCaps &caps, skgpu::KeyBuilder *b) const

int	numChildProcessors () const

int	numNonNullChildProcessors () const

GrFragmentProcessor *	childProcessor (int index)

const GrFragmentProcessor *	childProcessor (int index) const

	SkDEBUGCODE (bool isInstantiated() const ;) bool willReadDstColor() const

bool	isBlendFunction () const

bool	usesSampleCoordsDirectly () const

bool	usesSampleCoords () const

const SkSL::SampleUsage &	sampleUsage () const

bool	compatibleWithCoverageAsAlpha () const

bool	preservesOpaqueInput () const

bool	hasConstantOutputForConstantInput (SkPMColor4f inputColor, SkPMColor4f *outputColor) const

bool	hasConstantOutputForConstantInput () const

void	clearConstantOutputForConstantInputFlag ()

bool	isEqual (const GrFragmentProcessor &that) const

void	visitProxies (const GrVisitProxyFunc &) const

void	visitTextureEffects (const std::function< void(const GrTextureEffect &)> &) const

void	visitWithImpls (const std::function< void(const GrFragmentProcessor &, ProgramImpl &)> &, ProgramImpl &) const

GrTextureEffect *	asTextureEffect ()

const GrTextureEffect *	asTextureEffect () const

Public Member Functions inherited from GrProcessor
virtual	~GrProcessor ()=default

void *	operator new (size_t size)

void *	operator new (size_t object_size, size_t footer_size)

void	operator delete (void *target)

void *	operator new (size_t size, void *placement)

void	operator delete (void target, void placement)

template<typename T >
const T &	cast () const

ClassID	classID () const

Static Public Member Functions
static GrFPResult	Make (std::unique_ptr< GrFragmentProcessor > inputFP, GrClipEdgeType edgeType, int n, const float edges[])

static GrFPResult	Make (std::unique_ptr< GrFragmentProcessor >, GrClipEdgeType, const SkPath &)

Static Public Member Functions inherited from GrFragmentProcessor
static std::unique_ptr< GrFragmentProcessor >	MakeColor (SkPMColor4f color)

static std::unique_ptr< GrFragmentProcessor >	MulInputByChildAlpha (std::unique_ptr< GrFragmentProcessor > child)

static std::unique_ptr< GrFragmentProcessor >	ApplyPaintAlpha (std::unique_ptr< GrFragmentProcessor > child)

static std::unique_ptr< GrFragmentProcessor >	ModulateRGBA (std::unique_ptr< GrFragmentProcessor > child, const SkPMColor4f &color)

static std::unique_ptr< GrFragmentProcessor >	OverrideInput (std::unique_ptr< GrFragmentProcessor >, const SkPMColor4f &)

static std::unique_ptr< GrFragmentProcessor >	DisableCoverageAsAlpha (std::unique_ptr< GrFragmentProcessor >)

static std::unique_ptr< GrFragmentProcessor >	DestColor ()

static std::unique_ptr< GrFragmentProcessor >	SwizzleOutput (std::unique_ptr< GrFragmentProcessor >, const skgpu::Swizzle &)

static std::unique_ptr< GrFragmentProcessor >	ClampOutput (std::unique_ptr< GrFragmentProcessor >)

static std::unique_ptr< GrFragmentProcessor >	Compose (std::unique_ptr< GrFragmentProcessor > f, std::unique_ptr< GrFragmentProcessor > g)

static std::unique_ptr< GrFragmentProcessor >	ColorMatrix (std::unique_ptr< GrFragmentProcessor > child, const float matrix[20], bool unpremulInput, bool clampRGBOutput, bool premulOutput)

static std::unique_ptr< GrFragmentProcessor >	SurfaceColor ()

static std::unique_ptr< GrFragmentProcessor >	DeviceSpace (std::unique_ptr< GrFragmentProcessor >)

static std::unique_ptr< GrFragmentProcessor >	Rect (std::unique_ptr< GrFragmentProcessor >, GrClipEdgeType, SkRect)

static GrFPResult	Circle (std::unique_ptr< GrFragmentProcessor >, GrClipEdgeType, SkPoint center, float radius)

static GrFPResult	Ellipse (std::unique_ptr< GrFragmentProcessor >, GrClipEdgeType, SkPoint center, SkPoint radii, const GrShaderCaps &)

static std::unique_ptr< GrFragmentProcessor >	HighPrecision (std::unique_ptr< GrFragmentProcessor >)

Static Public Attributes
static constexpr int	kMaxEdges = 8

Private Member Functions
std::unique_ptr< ProgramImpl >	onMakeProgramImpl () const override

void	onAddToKey (const GrShaderCaps &, skgpu::KeyBuilder *) const override

bool	onIsEqual (const GrFragmentProcessor &other) const override

Additional Inherited Members
Public Types inherited from GrProcessor
enum	ClassID { kNull_ClassID , kAttributeTestProcessor_ClassID , kBigKeyProcessor_ClassID , kBlendFragmentProcessor_ClassID , kBlockInputFragmentProcessor_ClassID , kButtCapStrokedCircleGeometryProcessor_ClassID , kCircleGeometryProcessor_ClassID , kCircularRRectEffect_ClassID , kClockwiseTestProcessor_ClassID , kColorTableEffect_ClassID , kCoverageSetOpXP_ClassID , kCustomXP_ClassID , kDashingCircleEffect_ClassID , kDashingLineEffect_ClassID , kDefaultGeoProc_ClassID , kDeviceSpace_ClassID , kDIEllipseGeometryProcessor_ClassID , kDisableColorXP_ClassID , kDrawAtlasPathShader_ClassID , kEllipseGeometryProcessor_ClassID , kEllipticalRRectEffect_ClassID , kFwidthSquircleTestProcessor_ClassID , kGP_ClassID , kGrBicubicEffect_ClassID , kGrBitmapTextGeoProc_ClassID , kGrColorSpaceXformEffect_ClassID , kGrConicEffect_ClassID , kGrConvexPolyEffect_ClassID , kGrDiffuseLightingEffect_ClassID , kGrDisplacementMapEffect_ClassID , kGrDistanceFieldA8TextGeoProc_ClassID , kGrDistanceFieldLCDTextGeoProc_ClassID , kGrDistanceFieldPathGeoProc_ClassID , kGrFillRRectOp_Processor_ClassID , kGrGaussianConvolutionFragmentProcessor_ClassID , kGrMatrixConvolutionEffect_ClassID , kGrMatrixEffect_ClassID , kGrMeshTestProcessor_ClassID , kGrMorphologyEffect_ClassID , kGrPerlinNoise2Effect_ClassID , kGrPipelineDynamicStateTestProcessor_ClassID , kGrQuadEffect_ClassID , kGrRRectShadowGeoProc_ClassID , kGrSkSLFP_ClassID , kGrSpecularLightingEffect_ClassID , kGrTextureEffect_ClassID , kGrUnrolledBinaryGradientColorizer_ClassID , kGrYUVtoRGBEffect_ClassID , kHighPrecisionFragmentProcessor_ClassID , kLatticeGP_ClassID , kPDLCDXferProcessor_ClassID , kPorterDuffXferProcessor_ClassID , kPremulFragmentProcessor_ClassID , kQuadEdgeEffect_ClassID , kQuadPerEdgeAAGeometryProcessor_ClassID , kSeriesFragmentProcessor_ClassID , kShaderPDXferProcessor_ClassID , kSurfaceColorProcessor_ClassID , kSwizzleFragmentProcessor_ClassID , kTessellate_BoundingBoxShader_ClassID , kTessellate_GrModulateAtlasCoverageEffect_ClassID , kTessellate_GrStrokeTessellationShader_ClassID , kTessellate_HullShader_ClassID , kTessellate_MiddleOutShader_ClassID , kTessellate_SimpleTriangleShader_ClassID , kTessellationTestTriShader_ClassID , kTestFP_ClassID , kTestRectOp_ClassID , kVertexColorSpaceBenchGP_ClassID , kVerticesGP_ClassID }

Protected Types inherited from GrFragmentProcessor
enum	OptimizationFlags : uint32_t { kNone_OptimizationFlags , kCompatibleWithCoverageAsAlpha_OptimizationFlag = 0x1 , kPreservesOpaqueInput_OptimizationFlag = 0x2 , kConstantOutputForConstantInput_OptimizationFlag = 0x4 , kAll_OptimizationFlags }

Protected Member Functions inherited from GrFragmentProcessor
	GrFragmentProcessor (ClassID classID, OptimizationFlags optimizationFlags)

	GrFragmentProcessor (const GrFragmentProcessor &src)

OptimizationFlags	optimizationFlags () const

void	registerChild (std::unique_ptr< GrFragmentProcessor > child, SkSL::SampleUsage sampleUsage=SkSL::SampleUsage::PassThrough())

void	cloneAndRegisterAllChildProcessors (const GrFragmentProcessor &src)

void	setUsesSampleCoordsDirectly ()

void	setWillReadDstColor ()

void	setIsBlendFunction ()

void	mergeOptimizationFlags (OptimizationFlags flags)

Protected Member Functions inherited from GrProcessor
	GrProcessor (ClassID classID)

	GrProcessor (const GrProcessor &)=delete

GrProcessor &	operator= (const GrProcessor &)=delete

Static Protected Member Functions inherited from GrFragmentProcessor
static OptimizationFlags	ModulateForSamplerOptFlags (SkAlphaType alphaType, bool samplingDecal)

static OptimizationFlags	ModulateForClampedSamplerOptFlags (SkAlphaType alphaType)

static OptimizationFlags	ProcessorOptimizationFlags (const GrFragmentProcessor *fp)

static SkPMColor4f	ConstantOutputForConstantInput (const GrFragmentProcessor *fp, const SkPMColor4f &input)

Protected Attributes inherited from GrProcessor
const ClassID	fClassID

Detailed Description

An effect that renders a convex polygon. It is intended to be used as a coverage effect. Bounding geometry is rendered and the effect computes coverage based on the fragment's position relative to the polygon.

Definition at line 30 of file GrConvexPolyEffect.h.

Constructor & Destructor Documentation

◆ ~GrConvexPolyEffect()

GrConvexPolyEffect::~GrConvexPolyEffect ( )

override

Definition at line 104 of file GrConvexPolyEffect.cpp.

104{}

Member Function Documentation

◆ clone()

std::unique_ptr< GrFragmentProcessor > GrConvexPolyEffect::clone ( ) const

overridevirtual

Makes a copy of this fragment processor that draws equivalently to the original. If the processor has child processors they are cloned as well.

Implements GrFragmentProcessor.

Definition at line 193 of file GrConvexPolyEffect.cpp.

                                                                   {
    return std::unique_ptr<GrFragmentProcessor>(new GrConvexPolyEffect(*this));
}

◆ Make() [1/2]

static GrFPResult GrConvexPolyEffect::Make	(	std::unique_ptr< GrFragmentProcessor >	inputFP,
		GrClipEdgeType	edgeType,
		int	n,
		const float	edges[]
	)

inlinestatic

edges is a set of n edge equations where n is limited to kMaxEdges. It contains 3*n values. The edges should form a convex polygon. The positive half-plane is considered to be the inside. The equations should be normalized such that the first two coefficients are a unit 2d vector.

Currently the edges are specified in device space. In the future we may prefer to specify them in src space. There are a number of ways this could be accomplished but we'd probably have to modify the effect/shaderbuilder interface to make it possible (e.g. give access to the view matrix or untransformed positions in the fragment shader).

Definition at line 45 of file GrConvexPolyEffect.h.

                                                {
        if (n <= 0 || n > kMaxEdges) {
            return GrFPFailure(std::move(inputFP));
        }
 
        return GrFPSuccess(std::unique_ptr<GrFragmentProcessor>(
                    new GrConvexPolyEffect(std::move(inputFP), edgeType, n, edges)));
    }

◆ Make() [2/2]

GrFPResult GrConvexPolyEffect::Make	(	std::unique_ptr< GrFragmentProcessor >	inputFP,
		GrClipEdgeType	type,
		const SkPath &	path
	)

static

Creates an effect that clips against the path. If the path is not a convex polygon, is inverse filled, or has too many edges, creation will fail.

Definition at line 35 of file GrConvexPolyEffect.cpp.

                                                                             {
    if (path.getSegmentMasks() != SkPath::kLine_SegmentMask || !path.isConvex()) {
        return GrFPFailure(std::move(inputFP));
    }
 
    SkPathFirstDirection dir = SkPathPriv::ComputeFirstDirection(path);
    // The only way this should fail is if the clip is effectively a infinitely thin line. In that
    // case nothing is inside the clip. It'd be nice to detect this at a higher level and either
    // skip the draw or omit the clip element.
    if (dir == SkPathFirstDirection::kUnknown) {
        if (GrClipEdgeTypeIsInverseFill(type)) {
            return GrFPSuccess(
                    GrFragmentProcessor::ModulateRGBA(std::move(inputFP), SK_PMColor4fWHITE));
        }
        // This could use ConstColor instead of ModulateRGBA but it would trigger a debug print
        // about a coverage processor not being compatible with the alpha-as-coverage optimization.
        // We don't really care about this unlikely case so we just use ModulateRGBA to suppress
        // the print.
        return GrFPSuccess(
                GrFragmentProcessor::ModulateRGBA(std::move(inputFP), SK_PMColor4fTRANSPARENT));
    }
 
    SkScalar        edges[3 * kMaxEdges];
    SkPoint         pts[4];
    SkPath::Verb    verb;
    SkPath::Iter    iter(path, true);
 
    // SkPath considers itself convex so long as there is a convex contour within it,
    // regardless of any degenerate contours such as a string of moveTos before it.
    // Iterate here to consume any degenerate contours and only process the points
    // on the actual convex contour.
    int n = 0;
    while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
        switch (verb) {
            case SkPath::kMove_Verb:
            case SkPath::kClose_Verb:
                break;
            case SkPath::kLine_Verb: {
                if (n >= kMaxEdges) {
                    return GrFPFailure(std::move(inputFP));
                }
                if (pts[0] != pts[1]) {
                    SkVector v = pts[1] - pts[0];
                    v.normalize();
                    if (SkPathFirstDirection::kCCW == dir) {
                        edges[3 * n] = v.fY;
                        edges[3 * n + 1] = -v.fX;
                    } else {
                        edges[3 * n] = -v.fY;
                        edges[3 * n + 1] = v.fX;
                    }
                    edges[3 * n + 2] = -(edges[3 * n] * pts[1].fX + edges[3 * n + 1] * pts[1].fY);
                    ++n;
                }
                break;
            }
            default:
                // Non-linear segment so not a polygon.
                return GrFPFailure(std::move(inputFP));
        }
    }
 
    if (path.isInverseFillType()) {
        type = GrInvertClipEdgeType(type);
    }
    return GrConvexPolyEffect::Make(std::move(inputFP), type, n, edges);
}

◆ name()

const char * GrConvexPolyEffect::name ( ) const

inlineoverridevirtual

Human-meaningful string to identify this processor; may be embedded in generated shader code and must be a legal SkSL identifier prefix.

Implements GrProcessor.

Definition at line 65 of file GrConvexPolyEffect.h.

65{ return "ConvexPoly"; }

◆ onAddToKey()

void GrConvexPolyEffect::onAddToKey	(	const GrShaderCaps &	caps,
		skgpu::KeyBuilder *	b
	)		const

overrideprivatevirtual

Implements GrFragmentProcessor.

Definition at line 106 of file GrConvexPolyEffect.cpp.

                                                                                      {
    static_assert(kGrClipEdgeTypeCnt <= 8);
    uint32_t key = (fEdgeCount << 3) | static_cast<int>(fEdgeType);
    b->add32(key);
}

◆ onIsEqual()

bool GrConvexPolyEffect::onIsEqual ( const GrFragmentProcessor & ) const

overrideprivatevirtual

Subclass implements this to support isEqual(). It will only be called if it is known that the two processors are of the same subclass (i.e. have the same ClassID).

Implements GrFragmentProcessor.

Definition at line 197 of file GrConvexPolyEffect.cpp.

                                                                         {
    const GrConvexPolyEffect& cpe = other.cast<GrConvexPolyEffect>();
    int n = 3*cpe.fEdgeCount;
    return cpe.fEdgeType == fEdgeType   &&
           cpe.fEdgeCount == fEdgeCount &&
           std::equal(cpe.fEdges.begin(), cpe.fEdges.begin() + n, fEdges.begin());
}

◆ onMakeProgramImpl()

std::unique_ptr< GrFragmentProcessor::ProgramImpl > GrConvexPolyEffect::onMakeProgramImpl ( ) const

overrideprivatevirtual

Returns a new instance of the appropriate ProgramImpl subclass for the given GrFragmentProcessor. It will emit the appropriate code and live with the cached program to setup uniform data for each draw that uses the program.

Implements GrFragmentProcessor.

Definition at line 112 of file GrConvexPolyEffect.cpp.

                                                                                          {
    class Impl : public ProgramImpl {
    public:
        void emitCode(EmitArgs& args) override {
            const GrConvexPolyEffect& cpe = args.fFp.cast<GrConvexPolyEffect>();
 
            const char *edgeArrayName;
            fEdgeUniform = args.fUniformHandler->addUniformArray(&cpe,
                                                                 kFragment_GrShaderFlag,
                                                                 SkSLType::kHalf3,
                                                                 "edgeArray",
                                                                 cpe.fEdgeCount,
                                                                 &edgeArrayName);
            GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
            fragBuilder->codeAppend("half alpha = 1.0;\n"
                                    "half edge;\n");
            for (int i = 0; i < cpe.fEdgeCount; ++i) {
                fragBuilder->codeAppendf("edge = dot(%s[%d], half3(sk_FragCoord.xy1));\n",
                                         edgeArrayName, i);
                if (GrClipEdgeTypeIsAA(cpe.fEdgeType)) {
                    fragBuilder->codeAppend("alpha *= saturate(edge);\n");
                } else {
                    fragBuilder->codeAppend("alpha *= step(0.5, edge);\n");
                }
            }
 
            if (GrClipEdgeTypeIsInverseFill(cpe.fEdgeType)) {
                fragBuilder->codeAppend("alpha = 1.0 - alpha;\n");
            }
 
            SkString inputSample = this->invokeChild(/*childIndex=*/0, args);
 
            fragBuilder->codeAppendf("return %s * alpha;\n", inputSample.c_str());
        }
 
    private:
        void onSetData(const GrGLSLProgramDataManager& pdman,
                       const GrFragmentProcessor& fp) override {
            const GrConvexPolyEffect& cpe = fp.cast<GrConvexPolyEffect>();
            size_t n = 3*cpe.fEdgeCount;
            if (!std::equal(fPrevEdges.begin(), fPrevEdges.begin() + n, cpe.fEdges.begin())) {
                pdman.set3fv(fEdgeUniform, cpe.fEdgeCount, cpe.fEdges.data());
                std::copy_n(cpe.fEdges.begin(), n, fPrevEdges.begin());
            }
        }
 
        GrGLSLProgramDataManager::UniformHandle              fEdgeUniform;
        std::array<float, 3 * GrConvexPolyEffect::kMaxEdges> fPrevEdges = {SK_FloatNaN};
    };
 
    return std::make_unique<Impl>();
}

Member Data Documentation

◆ kMaxEdges

constexpr int GrConvexPolyEffect::kMaxEdges = 8

inlinestaticconstexpr

Definition at line 32 of file GrConvexPolyEffect.h.

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

third_party/skia/src/gpu/ganesh/effects/GrConvexPolyEffect.h
third_party/skia/src/gpu/ganesh/effects/GrConvexPolyEffect.cpp

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~GrConvexPolyEffect()

Member Function Documentation

◆ clone()

◆ Make() [1/2]

◆ Make() [2/2]

◆ name()

◆ onAddToKey()

◆ onIsEqual()

◆ onMakeProgramImpl()

Member Data Documentation

◆ kMaxEdges