skgpu::graphite::Shape Class Reference

#include <Shape.h>

Public Types
enum class	Type : uint8_t {   kEmpty , kLine , kRect , kRRect ,   kPath }

Public Member Functions
	Shape ()
	Shape (const Shape &shape)
	Shape (Shape &&)=delete
	Shape (SkPoint p0, SkPoint p1)
	Shape (SkV2 p0, SkV2 p1)
	Shape (skvx::float2 p0, skvx::float2 p1)
	Shape (const Rect &rect)
	Shape (const SkRect &rect)
	Shape (const SkRRect &rrect)
	Shape (const SkPath &path)
	~Shape ()
Shape &	operator= (Shape &&)=delete
Shape &	operator= (const Shape &)
Type	type () const
bool	isEmpty () const
bool	isLine () const
bool	isRect () const
bool	isRRect () const
bool	isPath () const
bool	inverted () const
void	setInverted (bool inverted)
SkPathFillType	fillType () const
bool	conservativeContains (const Rect &rect) const
bool	conservativeContains (skvx::float2 point) const
bool	convex (bool simpleFill=true) const
Rect	bounds () const
SkPath	asPath () const
skvx::float2	p0 () const
skvx::float2	p1 () const
skvx::float4	line () const
const Rect &	rect () const
const SkRRect &	rrect () const
const SkPath &	path () const
void	setLine (SkPoint p0, SkPoint p1)
void	setLine (SkV2 p0, SkV2 p1)
void	setLine (skvx::float2 p0, skvx::float2 p1)
void	setRect (const SkRect &rect)
void	setRect (const Rect &rect)
void	setRRect (const SkRRect &rrect)
void	setPath (const SkPath &path)
void	reset ()
int	keySize () const
bool	hasKey () const
void	writeKey (uint32_t *key, bool includeInverted) const

Static Public Attributes
static constexpr int	kTypeCount = static_cast<int>(Type::kPath) + 1

Detailed Description

Shape is effectively a std::variant over different geometric shapes, with the most complex being an SkPath. It provides a consistent way to query geometric properties, such as convexity, point containment, or iteration.

Definition at line 28 of file Shape.h.

Member Enumeration Documentation

Type

enum class skgpu::graphite::Shape::Type : uint8_t

strong

Enumerator
kEmpty
kLine
kRect
kRRect
kPath

Definition at line 30 of file Shape.h.

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

Constructor & Destructor Documentation

Shape() [1/10]

skgpu::graphite::Shape::Shape ( )

inline

Definition at line 35 of file Shape.h.

{}

Shape() [2/10]

skgpu::graphite::Shape::Shape ( const Shape &  shape )

inline

Definition at line 36 of file Shape.h.

{ *this = shape; }

Shape() [3/10]

skgpu::graphite::Shape::Shape ( Shape &&  )

delete

Shape() [4/10]

skgpu::graphite::Shape::Shape ( SkPoint  p0, SkPoint  p1  )

inline

Definition at line 39 of file Shape.h.

{ this->setLine(p0, p1); }

Shape() [5/10]

skgpu::graphite::Shape::Shape ( SkV2  p0, SkV2  p1  )

inline

Definition at line 40 of file Shape.h.

{ this->setLine(p0, p1); }

Shape() [6/10]

skgpu::graphite::Shape::Shape ( skvx::float2  p0, skvx::float2  p1  )

inline

Definition at line 41 of file Shape.h.

{ this->setLine(p0, p1); }

Shape() [7/10]

skgpu::graphite::Shape::Shape ( const Rect &  rect )

inlineexplicit

Definition at line 42 of file Shape.h.

{ this->setRect(rect);   }

Shape() [8/10]

skgpu::graphite::Shape::Shape ( const SkRect &  rect )

inlineexplicit

Definition at line 43 of file Shape.h.

{ this->setRect(rect);   }

Shape() [9/10]

skgpu::graphite::Shape::Shape ( const SkRRect &  rrect )

inlineexplicit

Definition at line 44 of file Shape.h.

{ this->setRRect(rrect); }

Shape() [10/10]

skgpu::graphite::Shape::Shape ( const SkPath &  path )

inlineexplicit

Definition at line 45 of file Shape.h.

{ this->setPath(path);   }

~Shape()

skgpu::graphite::Shape::~Shape ( )

inline

Definition at line 47 of file Shape.h.

{ this->reset(); }

Member Function Documentation

asPath()

SkPath skgpu::graphite::Shape::asPath

(

)

const

Definition at line 80 of file Shape.cpp.

                           {
    if (fType == Type::kPath) {
        return fPath;
    }
 
    SkPathBuilder builder(this->fillType());
    switch (fType) {
        case Type::kEmpty: /* do nothing */                            break;
        case Type::kLine:  builder.moveTo(fRect.left(), fRect.top())
                                  .lineTo(fRect.right(), fRect.bot()); break;
        case Type::kRect:  builder.addRect(fRect.asSkRect());          break;
        case Type::kRRect: builder.addRRect(fRRect);                   break;
        case Type::kPath:  SkUNREACHABLE;
    }
    return builder.detach();
}

bounds()

Rect skgpu::graphite::Shape::bounds

(

)

const

Definition at line 69 of file Shape.cpp.

                         {
    switch (fType) {
        case Type::kEmpty: return Rect(0, 0, 0, 0);
        case Type::kLine:  return fRect.makeSorted(); // sorting corners computes bbox of segment
        case Type::kRect:  return fRect; // assuming it's sorted
        case Type::kRRect: return fRRect.getBounds();
        case Type::kPath:  return fPath.getBounds();
    }
    SkUNREACHABLE;
}

conservativeContains() [1/2]

bool skgpu::graphite::Shape::conservativeContains

(

const Rect &

rect

)

const

Definition at line 37 of file Shape.cpp.

                                                       {
    switch (fType) {
        case Type::kEmpty: return false;
        case Type::kLine:  return false;
        case Type::kRect:  return fRect.contains(rect);
        case Type::kRRect: return fRRect.contains(rect.asSkRect());
        case Type::kPath:  return fPath.conservativelyContainsRect(rect.asSkRect());
    }
    SkUNREACHABLE;
}

conservativeContains() [2/2]

bool skgpu::graphite::Shape::conservativeContains

(

skvx::float2

point

)

const

Definition at line 48 of file Shape.cpp.

                                                       {
    switch (fType) {
        case Type::kEmpty: return false;
        case Type::kLine:  return false;
        case Type::kRect:  return fRect.contains(Rect::Point(point));
        case Type::kRRect: return SkRRectPriv::ContainsPoint(fRRect, {point.x(), point.y()});
        case Type::kPath:  return fPath.contains(point.x(), point.y());
    }
    SkUNREACHABLE;
}

convex()

bool skgpu::graphite::Shape::convex

(

bool

simpleFill = true

)

const

Definition at line 59 of file Shape.cpp.

                                        {
    if (this->isPath()) {
        // SkPath.isConvex() really means "is this path convex were it to be closed".
        return (simpleFill || fPath.isLastContourClosed()) && fPath.isConvex();
    } else {
        // Every other shape type is convex by construction.
        return true;
    }
}

fillType()

SkPathFillType skgpu::graphite::Shape::fillType ( ) const

inline

Definition at line 77 of file Shape.h.

                                    {
        if (fType == Type::kPath) {
            return fPath.getFillType(); // already incorporates invertedness
        } else {
            return fInverted ? SkPathFillType::kInverseEvenOdd : SkPathFillType::kEvenOdd;
        }
    }

hasKey()

bool skgpu::graphite::Shape::hasKey ( ) const

inline

Definition at line 159 of file Shape.h.

{ return this->keySize() >= 0; }

inverted()

bool skgpu::graphite::Shape::inverted ( ) const

inline

Definition at line 65 of file Shape.h.

                          {
        SkASSERT(fType != Type::kPath || fInverted == fPath.isInverseFillType());
        return fInverted;
    }

isEmpty()

bool skgpu::graphite::Shape::isEmpty ( ) const

inline

Definition at line 59 of file Shape.h.

{ return fType == Type::kEmpty; }

isLine()

bool skgpu::graphite::Shape::isLine ( ) const

inline

Definition at line 60 of file Shape.h.

{ return fType == Type::kLine;  }

isPath()

bool skgpu::graphite::Shape::isPath ( ) const

inline

Definition at line 63 of file Shape.h.

{ return fType == Type::kPath;  }

isRect()

bool skgpu::graphite::Shape::isRect ( ) const

inline

Definition at line 61 of file Shape.h.

{ return fType == Type::kRect;  }

isRRect()

bool skgpu::graphite::Shape::isRRect ( ) const

inline

Definition at line 62 of file Shape.h.

{ return fType == Type::kRRect; }

keySize()

int skgpu::graphite::Shape::keySize

(

)

const

Gets the size of the key for the shape represented by this Shape. A negative value is returned if the shape has no key (shouldn't be cached).

Definition at line 140 of file Shape.cpp.

                         {
    int count = 1; // Every key has the state flags from the Shape
    switch(this->type()) {
        case Type::kLine:
            static_assert(0 == sizeof(skvx::float4) % sizeof(uint32_t));
            count += sizeof(skvx::float4) / sizeof(uint32_t);
            break;
        case Type::kRect:
            static_assert(0 == sizeof(Rect) % sizeof(uint32_t));
            count += sizeof(Rect) / sizeof(uint32_t);
            break;
        case Type::kRRect:
            static_assert(0 == SkRRect::kSizeInMemory % sizeof(uint32_t));
            count += SkRRect::kSizeInMemory / sizeof(uint32_t);
            break;
        case Type::kPath: {
            if (this->path().isVolatile()) {
                return -1; // volatile, so won't be keyed
            }
            if (this->path().isEmpty()) {
                return -1; // empty, so won't be keyed
            }
            int dataKeySize = path_key_from_data_size(this->path());
            if (dataKeySize >= 0) {
                count += dataKeySize;
            } else {
                count++; // Just adds the gen ID.
            }
            break;
        }
        default:
            // else it's empty, which just needs the state flags for its key
            SkASSERT(this->isEmpty());
    }
    return count;
}

line()

skvx::float4 skgpu::graphite::Shape::line ( ) const

inline

Definition at line 104 of file Shape.h.

{ SkASSERT(this->isLine());  return fRect.ltrb();     }

operator=() [1/2]

Shape & skgpu::graphite::Shape::operator=

(

const Shape &

shape

)

Definition at line 24 of file Shape.cpp.

                                          {
    switch (shape.type()) {
        case Type::kEmpty: this->reset();                         break;
        case Type::kLine:  this->setLine(shape.p0(), shape.p1()); break;
        case Type::kRect:  this->setRect(shape.rect());           break;
        case Type::kRRect: this->setRRect(shape.rrect());         break;
        case Type::kPath:  this->setPath(shape.path());           break;
    }
 
    fInverted = shape.fInverted;
    return *this;
}

operator=() [2/2]

Shape & skgpu::graphite::Shape::operator= ( Shape &&  )

delete

p0()

skvx::float2 skgpu::graphite::Shape::p0 ( ) const

inline

Definition at line 102 of file Shape.h.

{ SkASSERT(this->isLine());  return fRect.topLeft();  }

p1()

skvx::float2 skgpu::graphite::Shape::p1 ( ) const

inline

Definition at line 103 of file Shape.h.

{ SkASSERT(this->isLine());  return fRect.botRight(); }

path()

const SkPath & skgpu::graphite::Shape::path ( ) const

inline

Definition at line 107 of file Shape.h.

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

rect()

const Rect & skgpu::graphite::Shape::rect ( ) const

inline

Definition at line 105 of file Shape.h.

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

reset()

void skgpu::graphite::Shape::reset ( )

inline

Definition at line 148 of file Shape.h.

                 {
        this->setType(Type::kEmpty);
        fInverted = false;
    }

rrect()

const SkRRect & skgpu::graphite::Shape::rrect ( ) const

inline

Definition at line 106 of file Shape.h.

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

setInverted()

void skgpu::graphite::Shape::setInverted ( bool  inverted )

inline

Definition at line 70 of file Shape.h.

                                    {
        if (fType == Type::kPath && inverted != fPath.isInverseFillType()) {
            fPath.toggleInverseFillType();
        }
        fInverted = inverted;
    }

setLine() [1/3]

void skgpu::graphite::Shape::setLine ( SkPoint  p0, SkPoint  p1  )

inline

Definition at line 114 of file Shape.h.

                                         {
        this->setLine(skvx::float2{p0.fX, p0.fY}, skvx::float2{p1.fX, p1.fY});
    }

setLine() [2/3]

void skgpu::graphite::Shape::setLine ( SkV2  p0, SkV2  p1  )

inline

Definition at line 117 of file Shape.h.

                                   {
        this->setLine(skvx::float2{p0.x, p0.y}, skvx::float2{p1.x, p1.y});
    }

setLine() [3/3]

void skgpu::graphite::Shape::setLine ( skvx::float2  p0, skvx::float2  p1  )

inline

Definition at line 120 of file Shape.h.

                                               {
        this->setType(Type::kLine);
        fRect = Rect(p0, p1);
        fInverted = false;
    }

setPath()

void skgpu::graphite::Shape::setPath ( const SkPath &  path )

inline

Definition at line 136 of file Shape.h.

                                     {
        if (fType == Type::kPath) {
            // Assign directly
            fPath = path;
        } else {
            // In-place initialize
            this->setType(Type::kPath);
            new (&fPath) SkPath(path);
        }
        fInverted = path.isInverseFillType();
    }

setRect() [1/2]

void skgpu::graphite::Shape::setRect ( const Rect &  rect )

inline

Definition at line 126 of file Shape.h.

                                   {
        this->setType(Type::kRect);
        fRect = rect;
        fInverted = false;
    }

setRect() [2/2]

void skgpu::graphite::Shape::setRect ( const SkRect &  rect )

inline

Definition at line 125 of file Shape.h.

{ this->setRect(Rect(rect)); }

setRRect()

void skgpu::graphite::Shape::setRRect ( const SkRRect &  rrect )

inline

Definition at line 131 of file Shape.h.

                                        {
        this->setType(Type::kRRect);
        fRRect = rrect;
        fInverted = false;
    }

type()

Type skgpu::graphite::Shape::type ( ) const

inline

Definition at line 57 of file Shape.h.

{ return fType; }

writeKey()

void skgpu::graphite::Shape::writeKey	(	uint32_t *	key,
		bool	includeInverted
	)		const

Writes keySize() bytes into the provided pointer. Assumes that there is enough space allocated for the key and that keySize() does not return a negative value for this shape. If includeInverted is false, non-inverted state will be written into the key regardless of the Shape's state.

Definition at line 177 of file Shape.cpp.

                                                              {
    SkASSERT(this->keySize());
    SkDEBUGCODE(uint32_t* origKey = key;)
 
    // Every key starts with the state from the Shape (this includes path fill type,
    // and any tracked inversion, as well as the class of geometry).
    *key++ = this->stateKey(includeInverted);
 
    switch(this->type()) {
        case Type::kPath: {
            SkASSERT(!this->path().isVolatile());
            SkASSERT(!this->path().isEmpty());
            // Ensure that the path's inversion matches our state so that the path's key suffices.
            SkASSERT(this->inverted() == this->path().isInverseFillType());
 
            int dataKeySize = path_key_from_data_size(this->path());
            if (dataKeySize >= 0) {
                write_path_key_from_data(this->path(), key);
                return;
            } else {
                *key++ = this->path().getGenerationID();
            }
            break;
        }
        case Type::kRect:
            memcpy(key, &this->rect(), sizeof(Rect));
            key += sizeof(Rect) / sizeof(uint32_t);
            break;
        case Type::kRRect:
            this->rrect().writeToMemory(key);
            key += SkRRect::kSizeInMemory / sizeof(uint32_t);
            break;
        case Type::kLine: {
            skvx::float4 line = this->line();
            memcpy(key, &line, sizeof(skvx::float4));
            key += sizeof(skvx::float4) / sizeof(uint32_t);
            break;
        }
        default:
            // Nothing other than the flag state is needed in the key for an empty shape
            SkASSERT(this->isEmpty());
    }
    SkASSERT(key - origKey == this->keySize());
}

Member Data Documentation

fPath

SkPath skgpu::graphite::Shape::fPath

Definition at line 188 of file Shape.h.

fRect

Rect skgpu::graphite::Shape::fRect

Definition at line 186 of file Shape.h.

fRRect

SkRRect skgpu::graphite::Shape::fRRect

Definition at line 187 of file Shape.h.

kTypeCount

constexpr int skgpu::graphite::Shape::kTypeCount = static_cast<int>(Type::kPath) + 1

inlinestaticconstexpr

Definition at line 33 of file Shape.h.

---

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

• third_party/skia/src/gpu/graphite/geom/Shape.h
• third_party/skia/src/gpu/graphite/geom/Shape.cpp