GrShape Class Reference

#include <GrShape.h>

Public Types
enum class	Type : uint8_t {   kEmpty , kPoint , kRect , kRRect ,   kPath , kArc , kLine }
enum	SimplifyFlags : unsigned { kSimpleFill_Flag = 0b001 , kIgnoreWinding_Flag = 0b010 , kMakeCanonical_Flag = 0b100 , kAll_Flags = 0b111 }
using	sk_is_trivially_relocatable = std::true_type

Public Member Functions
	GrShape ()
	GrShape (const SkPoint &point)
	GrShape (const SkRect &rect)
	GrShape (const SkRRect &rrect)
	GrShape (const SkPath &path)
	GrShape (const SkArc &arc)
	GrShape (const GrLineSegment &line)
	GrShape (const GrShape &shape)
	~GrShape ()
GrShape &	operator= (const GrShape &shape)
bool	isEmpty () const
bool	isPoint () const
bool	isRect () const
bool	isRRect () const
bool	isPath () const
bool	isArc () const
bool	isLine () const
Type	type () const
uint32_t	stateKey () const
bool	inverted () const
SkPathDirection	dir () const
unsigned	startIndex () const
void	setPathWindingParams (SkPathDirection dir, unsigned start)
void	setInverted (bool inverted)
SkPoint &	point ()
const SkPoint &	point () const
SkRect &	rect ()
const SkRect &	rect () const
SkRRect &	rrect ()
const SkRRect &	rrect () const
SkPath &	path ()
const SkPath &	path () const
SkArc &	arc ()
const SkArc &	arc () const
GrLineSegment &	line ()
const GrLineSegment &	line () const
void	setPoint (const SkPoint &point)
void	setRect (const SkRect &rect)
void	setRRect (const SkRRect &rrect)
void	setArc (const SkArc &arc)
void	setLine (const GrLineSegment &line)
void	setPath (const SkPath &path)
void	reset ()
bool	simplify (unsigned flags=kAll_Flags)
bool	conservativeContains (const SkRect &rect) const
bool	conservativeContains (const SkPoint &point) const
bool	closed () const
bool	convex (bool simpleFill=true) const
SkRect	bounds () const
uint32_t	segmentMask () const
void	asPath (SkPath *out, bool simpleFill=true) const

Static Public Attributes
static constexpr int	kTypeCount = static_cast<int>(Type::kLine) + 1
static constexpr SkPathDirection	kDefaultDir = SkPathDirection::kCW
static constexpr unsigned	kDefaultStart = 0
static constexpr SkPathFillType	kDefaultFillType = SkPathFillType::kEvenOdd

Detailed Description

GrShape is a convenience class to represent the many different specialized geometries that Ganesh can handle, including rects, round rects, lines, as well as paths. It is intended as a data-only class where any additional complex behavior is handled by an owning type (e.g. GrStyledShape). However, it does include some basic utilities that unify common functionality (such as contains()) from the underlying shape types.

In order to have lossless simplification of the geometry, it also tracks winding direction, start index, and fill inversion. The direction and index are match the SkPath indexing scheme for the shape's type (e.g. rect, rrect, or oval).

Regarding GrShape's empty shape:

• GrShape uses empty to refer to the absence of any geometric data
• SkRect::isEmpty() returns true if the rect is not sorted, even if it has area. GrShape will not simplify these shapes to an empty GrShape. Rects with actual 0 width and height will simplify to a point or line, not empty. This is to preserve geometric data for path effects and strokes.
• SkRRect::isEmpty() is true when the bounds have 0 width or height, so GrShape will simplify it to a point or line, just like a rect. SkRRect does not have the concept of unsorted edges.

Definition at line 50 of file GrShape.h.

Member Typedef Documentation

sk_is_trivially_relocatable

using GrShape::sk_is_trivially_relocatable = std::true_type

Definition at line 234 of file GrShape.h.

Member Enumeration Documentation

SimplifyFlags

enum GrShape::SimplifyFlags : unsigned

Enumerator
kSimpleFill_Flag
kIgnoreWinding_Flag
kMakeCanonical_Flag
kAll_Flags

Definition at line 193 of file GrShape.h.

                       : unsigned {
        // If set, it is assumed the original shape would have been implicitly filled when drawn or
        // clipped, so simpler shape types that are closed can still be considered. Shapes with
        // 0 area (i.e. points and lines) can be turned into empty.
        kSimpleFill_Flag    = 0b001,
        // If set, simplifications that would impact a directional stroke or path effect can still
        // be taken (e.g. dir and start are not required, arcs can be converted to ovals).
        kIgnoreWinding_Flag = 0b010,
        // If set, the geometry will be updated to have sorted coordinates (rects, lines), modulated
        // sweep angles (arcs).
        kMakeCanonical_Flag = 0b100,
 
        kAll_Flags          = 0b111
    };

Type

enum class GrShape::Type : uint8_t

strong

Enumerator
kEmpty
kPoint
kRect
kRRect
kPath
kArc
kLine

Definition at line 53 of file GrShape.h.

                    : uint8_t {
        kEmpty, kPoint, kRect, kRRect, kPath, kArc, kLine
    };

Constructor & Destructor Documentation

GrShape() [1/8]

GrShape::GrShape ( )

inline

Definition at line 65 of file GrShape.h.

{}

GrShape() [2/8]

GrShape::GrShape ( const SkPoint &  point )

inlineexplicit

Definition at line 66 of file GrShape.h.

{ this->setPoint(point); }

GrShape() [3/8]

GrShape::GrShape ( const SkRect &  rect )

inlineexplicit

Definition at line 67 of file GrShape.h.

{ this->setRect(rect); }

GrShape() [4/8]

GrShape::GrShape ( const SkRRect &  rrect )

inlineexplicit

Definition at line 68 of file GrShape.h.

{ this->setRRect(rrect); }

GrShape() [5/8]

GrShape::GrShape ( const SkPath &  path )

inlineexplicit

Definition at line 69 of file GrShape.h.

{ this->setPath(path); }

GrShape() [6/8]

GrShape::GrShape ( const SkArc &  arc )

inlineexplicit

Definition at line 70 of file GrShape.h.

{ this->setArc(arc); }

GrShape() [7/8]

GrShape::GrShape ( const GrLineSegment &  line )

inlineexplicit

Definition at line 71 of file GrShape.h.

{ this->setLine(line); }

GrShape() [8/8]

GrShape::GrShape ( const GrShape &  shape )

inline

Definition at line 73 of file GrShape.h.

{ *this = shape; }

~GrShape()

GrShape::~GrShape ( )

inline

Definition at line 75 of file GrShape.h.

{ this->reset(); }

Member Function Documentation

arc() [1/2]

SkArc & GrShape::arc ( )

inline

Definition at line 143 of file GrShape.h.

{ SkASSERT(this->isArc()); return fArc; }

arc() [2/2]

const SkArc & GrShape::arc ( ) const

inline

Definition at line 144 of file GrShape.h.

{ SkASSERT(this->isArc()); return fArc; }

asPath()

void GrShape::asPath	(	SkPath *	out,
		bool	simpleFill = true
	)		const

Definition at line 423 of file GrShape.cpp.

                                                       {
    if (!this->isPath() && !this->isArc()) {
        // When not a path, we need to set fill type on the path to match invertedness.
        // All the non-path geometries produce equivalent shapes with either even-odd or winding
        // so we can use the default fill type.
        out->reset();
        out->setFillType(kDefaultFillType);
        if (fInverted) {
            out->toggleInverseFillType();
        }
    } // Else when we're already a path, that will assign the fill type directly to 'out'.
 
    switch (this->type()) {
        case Type::kEmpty:
            return;
        case Type::kPoint:
            // A plain moveTo() or moveTo+close() does not match the expected path for a
            // point that is being dashed (see SkDashPath's handling of zero-length segments).
            out->moveTo(fPoint);
            out->lineTo(fPoint);
            return;
        case Type::kRect:
            out->addRect(fRect, this->dir(), this->startIndex());
            return;
        case Type::kRRect:
            out->addRRect(fRRect, this->dir(), this->startIndex());
            return;
        case Type::kPath:
            *out = fPath;
            return;
        case Type::kArc:
            SkPathPriv::CreateDrawArcPath(out, fArc, simpleFill);
            // CreateDrawArcPath resets the output path and configures its fill type, so we just
            // have to ensure invertedness is correct.
            if (fInverted) {
                out->toggleInverseFillType();
            }
            return;
        case Type::kLine:
            out->moveTo(fLine.fP1);
            out->lineTo(fLine.fP2);
            return;
    }
    SkUNREACHABLE;
}

bounds()

SkRect GrShape::bounds

(

)

const

Definition at line 367 of file GrShape.cpp.

                             {
    // Bounds where left == bottom or top == right can indicate a line or point shape. We return
    // inverted bounds for a truly empty shape.
    static constexpr SkRect kInverted = SkRect::MakeLTRB(1, 1, -1, -1);
    switch (this->type()) {
        case Type::kEmpty:
            return kInverted;
        case Type::kPoint:
            return {fPoint.fX, fPoint.fY, fPoint.fX, fPoint.fY};
        case Type::kRect:
            return fRect.makeSorted();
        case Type::kRRect:
            return fRRect.getBounds();
        case Type::kPath:
            return fPath.getBounds();
        case Type::kArc:
            return fArc.fOval;
        case Type::kLine: {
            SkRect b = SkRect::MakeLTRB(fLine.fP1.fX, fLine.fP1.fY,
                                        fLine.fP2.fX, fLine.fP2.fY);
            b.sort();
            return b; }
    }
    SkUNREACHABLE;
}

closed()

bool GrShape::closed

(

)

const

Definition at line 330 of file GrShape.cpp.

                           {
    switch (this->type()) {
        case Type::kEmpty: // fall through
        case Type::kRect:  // fall through
        case Type::kRRect:
            return true;
        case Type::kPath:
            // SkPath doesn't keep track of the closed status of each contour.
            return SkPathPriv::IsClosedSingleContour(fPath);
        case Type::kArc:
            return fArc.fType == SkArc::Type::kWedge;
        case Type::kPoint: // fall through
        case Type::kLine:
            return false;
    }
    SkUNREACHABLE;
}

conservativeContains() [1/2]

bool GrShape::conservativeContains

(

const SkPoint &

point

)

const

Definition at line 313 of file GrShape.cpp.

                                                             {
    switch (this->type()) {
        case Type::kEmpty:
        case Type::kPoint: // fall through, currently choosing not to test if shape == point
        case Type::kLine:  // fall through, ""
        case Type::kArc:
            return false;
        case Type::kRect:
            return fRect.contains(point.fX, point.fY);
        case Type::kRRect:
            return SkRRectPriv::ContainsPoint(fRRect, point);
        case Type::kPath:
            return fPath.contains(point.fX, point.fY);
    }
    SkUNREACHABLE;
}

conservativeContains() [2/2]

bool GrShape::conservativeContains

(

const SkRect &

rect

)

const

Definition at line 289 of file GrShape.cpp.

                                                           {
    switch (this->type()) {
        case Type::kEmpty:
        case Type::kPoint: // fall through since a point has 0 area
        case Type::kLine:  // fall through, "" (currently choosing not to test if 'rect' == line)
            return false;
        case Type::kRect:
            return fRect.contains(rect);
        case Type::kRRect:
            return fRRect.contains(rect);
        case Type::kPath:
            return fPath.conservativelyContainsRect(rect);
        case Type::kArc:
            if (fArc.fType == SkArc::Type::kWedge) {
                SkPath arc;
                this->asPath(&arc);
                return arc.conservativelyContainsRect(rect);
            } else {
                return false;
            }
    }
    SkUNREACHABLE;
}

convex()

bool GrShape::convex

(

bool

simpleFill = true

)

const

Definition at line 348 of file GrShape.cpp.

                                          {
    switch (this->type()) {
        case Type::kEmpty: // fall through
        case Type::kRect:  // fall through
        case Type::kRRect:
            return true;
        case Type::kPath:
            // SkPath.isConvex() really means "is this path convex were it to be closed".
            // Convex paths may only have one contour hence isLastContourClosed() is sufficient.
            return (simpleFill || fPath.isLastContourClosed()) && fPath.isConvex();
        case Type::kArc:
            return SkPathPriv::DrawArcIsConvex(fArc.fSweepAngle, fArc.fType, simpleFill);
        case Type::kPoint: // fall through
        case Type::kLine:
            return false;
    }
    SkUNREACHABLE;
}

dir()

SkPathDirection GrShape::dir ( ) const

inline

Definition at line 105 of file GrShape.h.

{ return fCW ? SkPathDirection::kCW : SkPathDirection::kCCW; }

inverted()

bool GrShape::inverted ( ) const

inline

Definition at line 99 of file GrShape.h.

                          {
        return this->isPath() ? fPath.isInverseFillType() : SkToBool(fInverted);
    }

isArc()

bool GrShape::isArc ( ) const

inline

Definition at line 89 of file GrShape.h.

{ return this->type() == Type::kArc; }

isEmpty()

bool GrShape::isEmpty ( ) const

inline

Definition at line 84 of file GrShape.h.

{ return this->type() == Type::kEmpty; }

isLine()

bool GrShape::isLine ( ) const

inline

Definition at line 90 of file GrShape.h.

{ return this->type() == Type::kLine; }

isPath()

bool GrShape::isPath ( ) const

inline

Definition at line 88 of file GrShape.h.

{ return this->type() == Type::kPath; }

isPoint()

bool GrShape::isPoint ( ) const

inline

Definition at line 85 of file GrShape.h.

{ return this->type() == Type::kPoint; }

isRect()

bool GrShape::isRect ( ) const

inline

Definition at line 86 of file GrShape.h.

{ return this->type() == Type::kRect; }

isRRect()

bool GrShape::isRRect ( ) const

inline

Definition at line 87 of file GrShape.h.

{ return this->type() == Type::kRRect; }

line() [1/2]

GrLineSegment & GrShape::line ( )

inline

Definition at line 146 of file GrShape.h.

{ SkASSERT(this->isLine()); return fLine; }

line() [2/2]

const GrLineSegment & GrShape::line ( ) const

inline

Definition at line 147 of file GrShape.h.

{ SkASSERT(this->isLine()); return fLine; }

operator=()

GrShape & GrShape::operator=

(

const GrShape &

shape

)

Definition at line 17 of file GrShape.cpp.

                                                {
    switch (shape.type()) {
        case Type::kEmpty:
            this->reset();
            break;
        case Type::kPoint:
            this->setPoint(shape.fPoint);
            break;
        case Type::kRect:
            this->setRect(shape.fRect);
            break;
        case Type::kRRect:
            this->setRRect(shape.fRRect);
            break;
        case Type::kPath:
            this->setPath(shape.fPath);
            break;
        case Type::kArc:
            this->setArc(shape.fArc);
            break;
        case Type::kLine:
            this->setLine(shape.fLine);
            break;
    }
 
    fStart = shape.fStart;
    fCW = shape.fCW;
    fInverted = shape.fInverted;
 
    return *this;
}

path() [1/2]

SkPath & GrShape::path ( )

inline

Definition at line 140 of file GrShape.h.

{ SkASSERT(this->isPath()); return fPath; }

path() [2/2]

const SkPath & GrShape::path ( ) const

inline

Definition at line 141 of file GrShape.h.

{ SkASSERT(this->isPath()); return fPath; }

point() [1/2]

SkPoint & GrShape::point ( )

inline

Definition at line 131 of file GrShape.h.

{ SkASSERT(this->isPoint()); return fPoint; }

point() [2/2]

const SkPoint & GrShape::point ( ) const

inline

Definition at line 132 of file GrShape.h.

{ SkASSERT(this->isPoint()); return fPoint; }

rect() [1/2]

SkRect & GrShape::rect ( )

inline

Definition at line 134 of file GrShape.h.

{ SkASSERT(this->isRect()); return fRect; }

rect() [2/2]

const SkRect & GrShape::rect ( ) const

inline

Definition at line 135 of file GrShape.h.

{ SkASSERT(this->isRect()); return fRect; }

reset()

void GrShape::reset ( )

inline

Definition at line 188 of file GrShape.h.

                 {
        this->reset(Type::kEmpty);
    }

rrect() [1/2]

SkRRect & GrShape::rrect ( )

inline

Definition at line 137 of file GrShape.h.

{ SkASSERT(this->isRRect()); return fRRect; }

rrect() [2/2]

const SkRRect & GrShape::rrect ( ) const

inline

Definition at line 138 of file GrShape.h.

{ SkASSERT(this->isRRect()); return fRRect; }

segmentMask()

uint32_t GrShape::segmentMask

(

)

const

Definition at line 393 of file GrShape.cpp.

                                    {
    // In order to match what a path would report, this has to inspect the shapes slightly
    // to reflect what they might simplify to.
    switch (this->type()) {
        case Type::kEmpty:
            return 0;
        case Type::kRRect:
            if (fRRect.isEmpty() || fRRect.isRect()) {
                return SkPath::kLine_SegmentMask;
            } else if (fRRect.isOval()) {
                return SkPath::kConic_SegmentMask;
            } else {
                return SkPath::kConic_SegmentMask | SkPath::kLine_SegmentMask;
            }
        case Type::kPath:
            return fPath.getSegmentMasks();
        case Type::kArc:
            if (fArc.fType == SkArc::Type::kWedge) {
                return SkPath::kConic_SegmentMask | SkPath::kLine_SegmentMask;
            } else {
                return SkPath::kConic_SegmentMask;
            }
        case Type::kPoint: // fall through
        case Type::kLine:  // ""
        case Type::kRect:
            return SkPath::kLine_SegmentMask;
    }
    SkUNREACHABLE;
}

setArc()

void GrShape::setArc ( const SkArc &  arc )

inline

Definition at line 167 of file GrShape.h.

                                  {
        this->reset(Type::kArc);
        fArc = arc;
    }

setInverted()

void GrShape::setInverted ( bool  inverted )

inline

Definition at line 119 of file GrShape.h.

                                    {
        if (this->isPath()) {
            if (inverted != fPath.isInverseFillType()) {
                fPath.toggleInverseFillType();
            }
        } else {
            fInverted = inverted;
        }
    }

setLine()

void GrShape::setLine ( const GrLineSegment &  line )

inline

Definition at line 171 of file GrShape.h.

                                            {
        this->reset(Type::kLine);
        fLine = line;
    }

setPath()

void GrShape::setPath ( const SkPath &  path )

inline

Definition at line 175 of file GrShape.h.

                                     {
        if (this->isPath()) {
            // Assign directly
            fPath = path;
        } else {
            // In-place initialize
            this->setType(Type::kPath);
            new (&fPath) SkPath(path);
        }
        // Must also set these since we didn't call reset() like other setX functions.
        this->setPathWindingParams(kDefaultDir, kDefaultStart);
        fInverted = path.isInverseFillType();
    }

setPathWindingParams()

void GrShape::setPathWindingParams ( SkPathDirection  dir, unsigned  start  )

inline

Definition at line 112 of file GrShape.h.

                                                                   {
        SkASSERT((this->isRect() && start < 4) || (this->isRRect() && start < 8) ||
                 (dir == kDefaultDir && start == kDefaultStart));
        fCW = dir == SkPathDirection::kCW;
        fStart = static_cast<uint8_t>(start);
    }

setPoint()

void GrShape::setPoint ( const SkPoint &  point )

inline

Definition at line 155 of file GrShape.h.

                                        {
        this->reset(Type::kPoint);
        fPoint = point;
    }

setRect()

void GrShape::setRect ( const SkRect &  rect )

inline

Definition at line 159 of file GrShape.h.

                                     {
        this->reset(Type::kRect);
        fRect = rect;
    }

setRRect()

void GrShape::setRRect ( const SkRRect &  rrect )

inline

Definition at line 163 of file GrShape.h.

                                        {
        this->reset(Type::kRRect);
        fRRect = rrect;
    }

simplify()

bool GrShape::simplify

(

unsigned

flags = kAll_Flags

)

Definition at line 244 of file GrShape.cpp.

                                     {
    // Verify that winding parameters are valid for the current type.
    SkASSERT((fType == Type::kRect || fType == Type::kRRect) ||
             (this->dir() == kDefaultDir && this->startIndex() == kDefaultStart));
 
    // The type specific functions automatically fall through to the simpler shapes, so
    // we only need to start in the right place.
    bool wasClosed = false;
    switch (fType) {
        case Type::kEmpty:
            // do nothing
            break;
        case Type::kPoint:
            this->simplifyPoint(fPoint, flags);
            break;
        case Type::kLine:
            this->simplifyLine(fLine.fP1, fLine.fP2, flags);
            break;
        case Type::kRect:
            this->simplifyRect(fRect, this->dir(), this->startIndex(), flags);
            wasClosed = true;
            break;
        case Type::kRRect:
            this->simplifyRRect(fRRect, this->dir(), this->startIndex(), flags);
            wasClosed = true;
            break;
        case Type::kPath:
            wasClosed = this->simplifyPath(flags);
            break;
        case Type::kArc:
            wasClosed = this->simplifyArc(flags);
            break;
 
        default:
            SkUNREACHABLE;
    }
 
    if (((flags & kIgnoreWinding_Flag) || (fType != Type::kRect && fType != Type::kRRect))) {
        // Reset winding parameters if we don't need them anymore
        this->setPathWindingParams(kDefaultDir, kDefaultStart);
    }
 
    return wasClosed;
}

startIndex()

unsigned GrShape::startIndex ( ) const

inline

Definition at line 108 of file GrShape.h.

{ return fStart; }

stateKey()

uint32_t GrShape::stateKey

(

)

const

Definition at line 49 of file GrShape.cpp.

                                 {
    // Use the path's full fill type instead of just whether or not it's inverted.
    uint32_t key = this->isPath() ? static_cast<uint32_t>(fPath.getFillType())
                                  : (fInverted ? 1 : 0);
    key |= ((uint32_t) fType) << 2; // fill type was 2 bits
    key |= fStart             << 5; // type was 3 bits, total 5 bits so far
    key |= (fCW ? 1 : 0)      << 8; // start was 3 bits, total 8 bits so far
    return key;
}

type()

Type GrShape::type ( ) const

inline

Definition at line 92 of file GrShape.h.

{ return fType; }

Member Data Documentation

fArc

SkArc GrShape::fArc

Definition at line 274 of file GrShape.h.

fLine

GrLineSegment GrShape::fLine

Definition at line 275 of file GrShape.h.

fPath

SkPath GrShape::fPath

Definition at line 273 of file GrShape.h.

fPoint

SkPoint GrShape::fPoint

Definition at line 270 of file GrShape.h.

fRect

SkRect GrShape::fRect

Definition at line 271 of file GrShape.h.

fRRect

SkRRect GrShape::fRRect

Definition at line 272 of file GrShape.h.

kDefaultDir

constexpr SkPathDirection GrShape::kDefaultDir = SkPathDirection::kCW

inlinestaticconstexpr

Definition at line 60 of file GrShape.h.

kDefaultFillType

constexpr SkPathFillType GrShape::kDefaultFillType = SkPathFillType::kEvenOdd

inlinestaticconstexpr

Definition at line 63 of file GrShape.h.

kDefaultStart

constexpr unsigned GrShape::kDefaultStart = 0

inlinestaticconstexpr

Definition at line 61 of file GrShape.h.

kTypeCount

constexpr int GrShape::kTypeCount = static_cast<int>(Type::kLine) + 1

inlinestaticconstexpr

Definition at line 56 of file GrShape.h.

---

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

• third_party/skia/src/gpu/ganesh/geometry/GrShape.h
• third_party/skia/src/gpu/ganesh/geometry/GrShape.cpp