sksg::Merge Class Reference

#include <SkSGMerge.h>

Inheritance diagram for sksg::Merge:

Classes
struct	Rec

Public Types
enum class	Mode {   kMerge , kUnion , kIntersect , kDifference ,   kReverseDifference , kXOR }

Public Member Functions
	~Merge () override
Public Member Functions inherited from sksg::GeometryNode
void	clip (SkCanvas *, bool antiAlias) const
void	draw (SkCanvas *, const SkPaint &) const
bool	contains (const SkPoint &) const
SkPath	asPath () const
Public Member Functions inherited from sksg::Node
const SkRect &	revalidate (InvalidationController *, const SkMatrix &)
void	invalidate (bool damage=true)
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Static Public Member Functions
static sk_sp< Merge >	Make (std::vector< Rec > &&recs)

Protected Member Functions
void	onClip (SkCanvas *, bool antiAlias) const override
void	onDraw (SkCanvas *, const SkPaint &) const override
bool	onContains (const SkPoint &) const override
SkRect	onRevalidate (InvalidationController *, const SkMatrix &) override
SkPath	onAsPath () const override
Protected Member Functions inherited from sksg::GeometryNode
	GeometryNode ()
Protected Member Functions inherited from sksg::Node
	Node (uint32_t invalTraits)
	~Node () override
const SkRect &	bounds () const
bool	hasInval () const
void	observeInval (const sk_sp< Node > &)
void	unobserveInval (const sk_sp< Node > &)

Additional Inherited Members
Protected Types inherited from sksg::Node
enum	InvalTraits { kBubbleDamage_Trait = 1 << 0 , kOverrideDamage_Trait = 1 << 1 }

Detailed Description

Concrete Geometry node, combining other geometries based on Mode.

Definition at line 30 of file SkSGMerge.h.

Member Enumeration Documentation

Mode

enum class sksg::Merge::Mode

strong

Enumerator
kMerge
kUnion
kIntersect
kDifference
kReverseDifference
kXOR

Definition at line 32 of file SkSGMerge.h.

                    {
        // Append path mode.
        kMerge,
 
        // SkPathOp ops.
        kUnion,
        kIntersect,
        kDifference,
        kReverseDifference,
        kXOR,
    };

Constructor & Destructor Documentation

~Merge()

sksg::Merge::~Merge ( )

override

Definition at line 29 of file SkSGMerge.cpp.

              {
    for (const auto& rec : fRecs) {
        this->unobserveInval(rec.fGeo);
    }
}

Member Function Documentation

Make()

static sk_sp< Merge > sksg::Merge::Make ( std::vector< Rec > &&  recs )

inlinestatic

Definition at line 49 of file SkSGMerge.h.

                                                    {
        return sk_sp<Merge>(new Merge(std::move(recs)));
    }

onAsPath()

SkPath sksg::Merge::onAsPath ( ) const

overrideprotectedvirtual

Implements sksg::GeometryNode.

Definition at line 47 of file SkSGMerge.cpp.

                             {
    return fMerged;
}

onClip()

void sksg::Merge::onClip ( SkCanvas *  canvas, bool  antiAlias  ) const

overrideprotectedvirtual

Implements sksg::GeometryNode.

Definition at line 35 of file SkSGMerge.cpp.

                                                         {
    canvas->clipPath(fMerged, SkClipOp::kIntersect, antiAlias);
}

onContains()

bool sksg::Merge::onContains ( const SkPoint &  p ) const

overrideprotectedvirtual

Implements sksg::GeometryNode.

Definition at line 43 of file SkSGMerge.cpp.

                                             {
    return fMerged.contains(p.x(), p.y());
}

onDraw()

void sksg::Merge::onDraw ( SkCanvas *  canvas, const SkPaint &  paint  ) const

overrideprotectedvirtual

Implements sksg::GeometryNode.

Definition at line 39 of file SkSGMerge.cpp.

                                                               {
    canvas->drawPath(fMerged, paint);
}

onRevalidate()

SkRect sksg::Merge::onRevalidate ( InvalidationController *  ic, const SkMatrix &  ctm  )

overrideprotectedvirtual

Implements sksg::Node.

Definition at line 70 of file SkSGMerge.cpp.

                                                                          {
    SkASSERT(this->hasInval());
 
    SkOpBuilder builder;
 
    fMerged.reset();
    bool in_builder = false;
 
    auto append = [&](const SkPath& path) {
        if (in_builder) {
            builder.resolve(&fMerged);
            in_builder = false;
        }
 
        if (fMerged.isEmpty()) {
            // First merge path determines the fill type.
            fMerged = path;
        } else {
            fMerged.addPath(path);
        }
    };
 
    for (const auto& rec : fRecs) {
        rec.fGeo->revalidate(ic, ctm);
 
        if (rec.fMode == Mode::kMerge) {
            // Merge (append) is not supported by SkOpBuidler.
            append(rec.fGeo->asPath());
            continue;
        }
 
        if (!in_builder) {
            builder.add(fMerged, kUnion_SkPathOp);
            in_builder = true;
        }
 
        builder.add(rec.fGeo->asPath(), mode_to_op(rec.fMode));
    }
 
    if (in_builder) {
        builder.resolve(&fMerged);
    }
 
    SkPathPriv::ShrinkToFit(&fMerged);
 
    return fMerged.computeTightBounds();
}

---

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

• third_party/skia/modules/sksg/include/SkSGMerge.h
• third_party/skia/modules/sksg/src/SkSGMerge.cpp