#include <SkRegion.h>

Classes
class	Cliperator

class	Iterator

struct	RunHead

class	Spanerator

Public Types
enum	Op { kDifference_Op , kIntersect_Op , kUnion_Op , kXOR_Op , kReverseDifference_Op , kReplace_Op , kLastOp = kReplace_Op }

using	sk_is_trivially_relocatable = std::true_type

Public Member Functions
	SkRegion ()

	SkRegion (const SkRegion &region)

	SkRegion (const SkIRect &rect)

	~SkRegion ()

SkRegion &	operator= (const SkRegion &region)

bool	operator== (const SkRegion &other) const

bool	operator!= (const SkRegion &other) const

bool	set (const SkRegion &src)

void	swap (SkRegion &other)

bool	isEmpty () const

bool	isRect () const

bool	isComplex () const

const SkIRect &	getBounds () const

int	computeRegionComplexity () const

bool	getBoundaryPath (SkPath *path) const

bool	setEmpty ()

bool	setRect (const SkIRect &rect)

bool	setRects (const SkIRect rects[], int count)

bool	setRegion (const SkRegion &region)

bool	setPath (const SkPath &path, const SkRegion &clip)

bool	intersects (const SkIRect &rect) const

bool	intersects (const SkRegion &other) const

bool	contains (int32_t x, int32_t y) const

bool	contains (const SkIRect &other) const

bool	contains (const SkRegion &other) const

bool	quickContains (const SkIRect &r) const

bool	quickReject (const SkIRect &rect) const

bool	quickReject (const SkRegion &rgn) const

void	translate (int dx, int dy)

void	translate (int dx, int dy, SkRegion *dst) const

bool	op (const SkIRect &rect, Op op)

bool	op (const SkRegion &rgn, Op op)

bool	op (const SkIRect &rect, const SkRegion &rgn, Op op)

bool	op (const SkRegion &rgn, const SkIRect &rect, Op op)

bool	op (const SkRegion &rgna, const SkRegion &rgnb, Op op)

size_t	writeToMemory (void *buffer) const

size_t	readFromMemory (const void *buffer, size_t length)

Static Public Attributes
static const int	kOpCnt = kLastOp + 1

Friends
struct	RunHead

class	Iterator

class	Spanerator

class	SkRegionPriv

class	SkRgnBuilder

class	SkFlatRegion

Detailed Description

SkRegion describes the set of pixels used to clip SkCanvas. SkRegion is compact, efficiently storing a single integer rectangle, or a run length encoded array of rectangles. SkRegion may reduce the current SkCanvas clip, or may be drawn as one or more integer rectangles. SkRegion iterator returns the scan lines or rectangles contained by it, optionally intersecting a bounding rectangle.

Definition at line 30 of file SkRegion.h.

Member Typedef Documentation

◆ sk_is_trivially_relocatable

using SkRegion::sk_is_trivially_relocatable = std::true_type

Definition at line 616 of file SkRegion.h.

Member Enumeration Documentation

◆ Op

enum SkRegion::Op

Enumerator
kDifference_Op	target minus operand
kIntersect_Op	target intersected with operand
kUnion_Op	target unioned with operand
kXOR_Op	target exclusive or with operand
kReverseDifference_Op	operand minus target
kReplace_Op	replace target with operand
kLastOp	last operator

Definition at line 366 of file SkRegion.h.

            {
        kDifference_Op,                      //!< target minus operand
        kIntersect_Op,                       //!< target intersected with operand
        kUnion_Op,                           //!< target unioned with operand
        kXOR_Op,                             //!< target exclusive or with operand
        kReverseDifference_Op,               //!< operand minus target
        kReplace_Op,                         //!< replace target with operand
        kLastOp               = kReplace_Op, //!< last operator
    };

Constructor & Destructor Documentation

◆ SkRegion() [1/3]

SkRegion::SkRegion ( )

Constructs an empty SkRegion. SkRegion is set to empty bounds at (0, 0) with zero width and height.

Returns: empty SkRegion

example: https://fiddle.skia.org/c/@Region_empty_constructor

Definition at line 123 of file SkRegion.cpp.

                   {
    fBounds.setEmpty();
    fRunHead = SkRegion_gEmptyRunHeadPtr;
}

◆ SkRegion() [2/3]

SkRegion::SkRegion ( const SkRegion & region )

Constructs a copy of an existing region. Copy constructor makes two regions identical by value. Internally, region and the returned result share pointer values. The underlying SkRect array is copied when modified.

Creating a SkRegion copy is very efficient and never allocates memory. SkRegion are always copied by value from the interface; the underlying shared pointers are not exposed.

Parameters

region SkRegion to copy by value

Returns: copy of SkRegion

example: https://fiddle.skia.org/c/@Region_copy_const_SkRegion

Definition at line 128 of file SkRegion.cpp.

                                      {
    fRunHead = SkRegion_gEmptyRunHeadPtr;   // just need a value that won't trigger sk_free(fRunHead)
    this->setRegion(src);
}

◆ SkRegion() [3/3]

SkRegion::SkRegion ( const SkIRect & rect )

explicit

Constructs a rectangular SkRegion matching the bounds of rect.

Parameters

rect	bounds of constructed SkRegion

Returns: rectangular SkRegion

example: https://fiddle.skia.org/c/@Region_copy_const_SkIRect

Definition at line 133 of file SkRegion.cpp.

                                      {
    fRunHead = SkRegion_gEmptyRunHeadPtr;   // just need a value that won't trigger sk_free(fRunHead)
    this->setRect(rect);
}

◆ ~SkRegion()

SkRegion::~SkRegion ( )

Releases ownership of any shared data and deletes data if SkRegion is sole owner.

example: https://fiddle.skia.org/c/@Region_destructor

Definition at line 138 of file SkRegion.cpp.

                    {
    this->freeRuns();
}

Member Function Documentation

◆ computeRegionComplexity()

int SkRegion::computeRegionComplexity ( ) const

Returns a value that increases with the number of elements in SkRegion. Returns zero if SkRegion is empty. Returns one if SkRegion equals SkIRect; otherwise, returns value greater than one indicating that SkRegion is complex.

Call to compare SkRegion for relative complexity.

Returns: relative complexity

example: https://fiddle.skia.org/c/@Region_computeRegionComplexity

Definition at line 176 of file SkRegion.cpp.

                                            {
  if (this->isEmpty()) {
    return 0;
  } else if (this->isRect()) {
    return 1;
  }
  return fRunHead->getIntervalCount();
}

◆ contains() [1/3]

bool SkRegion::contains ( const SkIRect & other ) const

Returns true if other is completely inside SkRegion. Returns false if SkRegion or other is empty.

Parameters

other SkIRect to contain

Returns: true if other is inside SkRegion

example: https://fiddle.skia.org/c/@Region_contains_2

Definition at line 422 of file SkRegion.cpp.

                                              {
    SkDEBUGCODE(SkRegionPriv::Validate(*this));
 
    if (!fBounds.contains(r)) {
        return false;
    }
    if (this->isRect()) {
        return true;
    }
    SkASSERT(this->isComplex());
 
    const RunType* scanline = fRunHead->findScanline(r.fTop);
    for (;;) {
        if (!scanline_contains(scanline, r.fLeft, r.fRight)) {
            return false;
        }
        if (r.fBottom <= scanline_bottom(scanline)) {
            break;
        }
        scanline = scanline_next(scanline);
    }
    return true;
}

◆ contains() [2/3]

bool SkRegion::contains ( const SkRegion & other ) const

Returns true if other is completely inside SkRegion. Returns false if SkRegion or other is empty.

Parameters

other SkRegion to contain

Returns: true if other is inside SkRegion

example: https://fiddle.skia.org/c/@Region_contains_3

Definition at line 446 of file SkRegion.cpp.

                                                 {
    SkDEBUGCODE(SkRegionPriv::Validate(*this));
    SkDEBUGCODE(SkRegionPriv::Validate(rgn));
 
    if (this->isEmpty() || rgn.isEmpty() || !fBounds.contains(rgn.fBounds)) {
        return false;
    }
    if (this->isRect()) {
        return true;
    }
    if (rgn.isRect()) {
        return this->contains(rgn.getBounds());
    }
 
    /*
     *  A contains B is equivalent to
     *  B - A == 0
     */
    return !Oper(rgn, *this, kDifference_Op, nullptr);
}

◆ contains() [3/3]

bool SkRegion::contains	(	int32_t	x,
		int32_t	y
	)		const

Returns true if SkIPoint (x, y) is inside SkRegion. Returns false if SkRegion is empty.

Parameters

x	test SkIPoint x-coordinate
y	test SkIPoint y-coordinate

Returns: true if (x, y) is inside SkRegion

example: https://fiddle.skia.org/c/@Region_contains

Definition at line 364 of file SkRegion.cpp.

                                                  {
    SkDEBUGCODE(SkRegionPriv::Validate(*this));
 
    if (!fBounds.contains(x, y)) {
        return false;
    }
    if (this->isRect()) {
        return true;
    }
    SkASSERT(this->isComplex());
 
    const RunType* runs = fRunHead->findScanline(y);
 
    // Skip the Bottom and IntervalCount
    runs += 2;
 
    // Just walk this scanline, checking each interval. The X-sentinel will
    // appear as a left-inteval (runs[0]) and should abort the search.
    //
    // We could do a bsearch, using interval-count (runs[1]), but need to time
    // when that would be worthwhile.
    //
    for (;;) {
        if (x < runs[0]) {
            break;
        }
        if (x < runs[1]) {
            return true;
        }
        runs += 2;
    }
    return false;
}

◆ getBoundaryPath()

bool SkRegion::getBoundaryPath ( SkPath * path ) const

Appends outline of SkRegion to path. Returns true if SkRegion is not empty; otherwise, returns false, and leaves path unmodified.

Parameters

path	SkPath to append to

Returns: true if path changed

example: https://fiddle.skia.org/c/@Region_getBoundaryPath

Definition at line 551 of file SkRegion_path.cpp.

                                                 {
    // path could safely be nullptr if we're empty, but the caller shouldn't
    // *know* that
    SkASSERT(path);
 
    if (this->isEmpty()) {
        return false;
    }
 
    const SkIRect& bounds = this->getBounds();
 
    if (this->isRect()) {
        SkRect  r;
        r.set(bounds);      // this converts the ints to scalars
        path->addRect(r);
        return true;
    }
 
    SkRegion::Iterator  iter(*this);
    SkTDArray<Edge>     edges;
 
    for (const SkIRect& r = iter.rect(); !iter.done(); iter.next()) {
        Edge* edge = edges.append(2);
        edge[0].set(r.fLeft, r.fBottom, r.fTop);
        edge[1].set(r.fRight, r.fTop, r.fBottom);
    }
 
    int count = edges.size();
    Edge* start = edges.begin();
    Edge* stop = start + count;
    SkTQSort<Edge>(start, stop, EdgeLT());
 
    Edge* e;
    for (e = start; e != stop; e++) {
        find_link(e, stop);
    }
 
#ifdef SK_DEBUG
    for (e = start; e != stop; e++) {
        SkASSERT(e->fNext != nullptr);
        SkASSERT(e->fFlags == Edge::kCompleteLink);
    }
#endif
 
    path->incReserve(count << 1);
    do {
        SkASSERT(count > 1);
        count -= extract_path(start, stop, path);
    } while (count > 0);
 
    return true;
}

◆ getBounds()

const SkIRect & SkRegion::getBounds ( ) const

inline

Returns minimum and maximum axes values of SkIRect array. Returns (0, 0, 0, 0) if SkRegion is empty.

Returns: combined bounds of all SkIRect elements

Definition at line 165 of file SkRegion.h.

165{ return fBounds; }

◆ intersects() [1/2]

bool SkRegion::intersects ( const SkIRect & rect ) const

Returns true if SkRegion intersects rect. Returns false if either rect or SkRegion is empty, or do not intersect.

Parameters

rect	SkIRect to intersect

Returns: true if rect and SkRegion have area in common

example: https://fiddle.skia.org/c/@Region_intersects

Definition at line 502 of file SkRegion.cpp.

                                                {
    SkDEBUGCODE(SkRegionPriv::Validate(*this));
 
    if (this->isEmpty() || r.isEmpty()) {
        return false;
    }
 
    SkIRect sect;
    if (!sect.intersect(fBounds, r)) {
        return false;
    }
    if (this->isRect()) {
        return true;
    }
    SkASSERT(this->isComplex());
 
    const RunType* scanline = fRunHead->findScanline(sect.fTop);
    for (;;) {
        if (scanline_intersects(scanline, sect.fLeft, sect.fRight)) {
            return true;
        }
        if (sect.fBottom <= scanline_bottom(scanline)) {
            break;
        }
        scanline = scanline_next(scanline);
    }
    return false;
}

◆ intersects() [2/2]

bool SkRegion::intersects ( const SkRegion & other ) const

Returns true if SkRegion intersects other. Returns false if either other or SkRegion is empty, or do not intersect.

Parameters

other SkRegion to intersect

Returns: true if other and SkRegion have area in common

example: https://fiddle.skia.org/c/@Region_intersects_2

Definition at line 531 of file SkRegion.cpp.

                                                   {
    if (this->isEmpty() || rgn.isEmpty()) {
        return false;
    }
 
    if (!SkIRect::Intersects(fBounds, rgn.fBounds)) {
        return false;
    }
 
    bool weAreARect = this->isRect();
    bool theyAreARect = rgn.isRect();
 
    if (weAreARect && theyAreARect) {
        return true;
    }
    if (weAreARect) {
        return rgn.intersects(this->getBounds());
    }
    if (theyAreARect) {
        return this->intersects(rgn.getBounds());
    }
 
    // both of us are complex
    return Oper(*this, rgn, kIntersect_Op, nullptr);
}

◆ isComplex()

bool SkRegion::isComplex ( ) const

inline

Returns true if SkRegion is described by more than one rectangle.

Returns: true if SkRegion contains more than one SkIRect

Definition at line 158 of file SkRegion.h.

158{ return !this->isEmpty() && !this->isRect(); }

◆ isEmpty()

bool SkRegion::isEmpty ( ) const

inline

Returns true if SkRegion is empty. Empty SkRegion has bounds width or height less than or equal to zero. SkRegion() constructs empty SkRegion; setEmpty() and setRect() with dimensionless data make SkRegion empty.

Returns: true if bounds has no width or height

Definition at line 146 of file SkRegion.h.

146{ return fRunHead == emptyRunHeadPtr(); }

◆ isRect()

bool SkRegion::isRect ( ) const

inline

Returns true if SkRegion is one SkIRect with positive dimensions.

Returns: true if SkRegion contains one SkIRect

Definition at line 152 of file SkRegion.h.

152{ return fRunHead == kRectRunHeadPtr; }

◆ op() [1/5]

bool SkRegion::op	(	const SkIRect &	rect,
		const SkRegion &	rgn,
		Op	op
	)

Replaces SkRegion with the result of rect op rgn. Returns true if replaced SkRegion is not empty.

Parameters

rect	SkIRect operand
rgn	SkRegion operand

Returns: false if result is empty

example: https://fiddle.skia.org/c/@Region_op_4

Definition at line 217 of file SkRegion.cpp.

                                                                 {
    SkRegion tmp(rect);
 
    return this->op(tmp, rgn, op);
}

◆ op() [2/5]

bool SkRegion::op	(	const SkIRect &	rect,
		Op	op
	)

inline

Replaces SkRegion with the result of SkRegion op rect. Returns true if replaced SkRegion is not empty.

Parameters

rect	SkIRect operand

Returns: false if result is empty

Definition at line 384 of file SkRegion.h.

                                        {
        if (this->isRect() && kIntersect_Op == op) {
            if (!fBounds.intersect(rect)) {
                return this->setEmpty();
            }
            return true;
        }
        return this->op(*this, rect, op);
    }

◆ op() [3/5]

bool SkRegion::op	(	const SkRegion &	rgn,
		const SkIRect &	rect,
		Op	op
	)

Replaces SkRegion with the result of rgn op rect. Returns true if replaced SkRegion is not empty.

Parameters

rgn	SkRegion operand
rect	SkIRect operand

Returns: false if result is empty

example: https://fiddle.skia.org/c/@Region_op_5

Definition at line 223 of file SkRegion.cpp.

                                                                 {
    SkRegion tmp(rect);
 
    return this->op(rgn, tmp, op);
}

◆ op() [4/5]

bool SkRegion::op	(	const SkRegion &	rgn,
		Op	op
	)

inline

Replaces SkRegion with the result of SkRegion op rgn. Returns true if replaced SkRegion is not empty.

Parameters

rgn	SkRegion operand

Returns: false if result is empty

Definition at line 400 of file SkRegion.h.

400{ return this->op(*this, rgn, op); }

◆ op() [5/5]

bool SkRegion::op	(	const SkRegion &	rgna,
		const SkRegion &	rgnb,
		Op	op
	)

Replaces SkRegion with the result of rgna op rgnb. Returns true if replaced SkRegion is not empty.

Parameters

rgna	SkRegion operand
rgnb	SkRegion operand

Returns: false if result is empty

example: https://fiddle.skia.org/c/@Region_op_6

Definition at line 1142 of file SkRegion.cpp.

                                                                   {
    SkDEBUGCODE(SkRegionPriv::Validate(*this));
    return SkRegion::Oper(rgna, rgnb, op, this);
}

◆ operator!=()

bool SkRegion::operator!= ( const SkRegion & other ) const

inline

Compares SkRegion and other; returns true if they do not enclose the same area.

Parameters

other SkRegion to compare

Returns: true if SkRegion pair are not equivalent

Definition at line 105 of file SkRegion.h.

                                                 {
        return !(*this == other);
    }

◆ operator=()

SkRegion & SkRegion::operator= ( const SkRegion & region )

Constructs a copy of an existing region. Makes two regions identical by value. Internally, region and the returned result share pointer values. The underlying SkRect array is copied when modified.

Creating a SkRegion copy is very efficient and never allocates memory. SkRegion are always copied by value from the interface; the underlying shared pointers are not exposed.

Parameters

region SkRegion to copy by value

Returns: SkRegion to copy by value

example: https://fiddle.skia.org/c/@Region_copy_operator

Definition at line 165 of file SkRegion.cpp.

                                                 {
    (void)this->setRegion(src);
    return *this;
}

◆ operator==()

bool SkRegion::operator== ( const SkRegion & other ) const

Compares SkRegion and other; returns true if they enclose exactly the same area.

Parameters

other SkRegion to compare

Returns: true if SkRegion pair are equivalent

example: https://fiddle.skia.org/c/@Region_equal1_operator

Definition at line 559 of file SkRegion.cpp.

                                                 {
    SkDEBUGCODE(SkRegionPriv::Validate(*this));
    SkDEBUGCODE(SkRegionPriv::Validate(b));
 
    if (this == &b) {
        return true;
    }
    if (fBounds != b.fBounds) {
        return false;
    }
 
    const SkRegion::RunHead* ah = fRunHead;
    const SkRegion::RunHead* bh = b.fRunHead;
 
    // this catches empties and rects being equal
    if (ah == bh) {
        return true;
    }
    // now we insist that both are complex (but different ptrs)
    if (!this->isComplex() || !b.isComplex()) {
        return false;
    }
    return  ah->fRunCount == bh->fRunCount &&
            !memcmp(ah->readonly_runs(), bh->readonly_runs(),
                    ah->fRunCount * sizeof(SkRegion::RunType));
}

◆ quickContains()

bool SkRegion::quickContains ( const SkIRect & r ) const

inline

Returns true if SkRegion is a single rectangle and contains r. May return false even though SkRegion contains r.

Parameters

r	SkIRect to contain

Returns: true quickly if r points are equal or inside

Definition at line 310 of file SkRegion.h.

                                               {
        SkASSERT(this->isEmpty() == fBounds.isEmpty()); // valid region
 
        return  r.fLeft < r.fRight && r.fTop < r.fBottom &&
                fRunHead == kRectRunHeadPtr &&  // this->isRect()
                /* fBounds.contains(left, top, right, bottom); */
                fBounds.fLeft <= r.fLeft   && fBounds.fTop <= r.fTop &&
                fBounds.fRight >= r.fRight && fBounds.fBottom >= r.fBottom;
    }

◆ quickReject() [1/2]

bool SkRegion::quickReject ( const SkIRect & rect ) const

inline

Returns true if SkRegion does not intersect rect. Returns true if rect is empty or SkRegion is empty. May return false even though SkRegion does not intersect rect.

Parameters

rect	SkIRect to intersect

Returns: true if rect does not intersect

Definition at line 327 of file SkRegion.h.

                                                {
        return this->isEmpty() || rect.isEmpty() ||
                !SkIRect::Intersects(fBounds, rect);
    }

◆ quickReject() [2/2]

bool SkRegion::quickReject ( const SkRegion & rgn ) const

inline

Returns true if SkRegion does not intersect rgn. Returns true if rgn is empty or SkRegion is empty. May return false even though SkRegion does not intersect rgn.

Parameters

rgn	SkRegion to intersect

Returns: true if rgn does not intersect

Definition at line 339 of file SkRegion.h.

                                                {
        return this->isEmpty() || rgn.isEmpty() ||
               !SkIRect::Intersects(fBounds, rgn.fBounds);
    }

◆ readFromMemory()

size_t SkRegion::readFromMemory	(	const void *	buffer,
		size_t	length
	)

Constructs SkRegion from buffer of size length. Returns bytes read. Returned value will be multiple of four or zero if length was too small.

Parameters

buffer	storage for binary data
length	size of buffer

Returns: bytes read

example: https://fiddle.skia.org/c/@Region_readFromMemory

Definition at line 1276 of file SkRegion.cpp.

                                                                  {
    SkRBuffer   buffer(storage, length);
    SkRegion    tmp;
    int32_t     count;
 
    // Serialized Region Format:
    //    Empty:
    //       -1
    //    Simple Rect:
    //       0  LEFT TOP RIGHT BOTTOM
    //    Complex Region:
    //       COUNT LEFT TOP RIGHT BOTTOM Y_SPAN_COUNT TOTAL_INTERVAL_COUNT [RUNS....]
    if (!buffer.readS32(&count) || count < -1) {
        return 0;
    }
    if (count >= 0) {
        if (!buffer.read(&tmp.fBounds, sizeof(tmp.fBounds)) || tmp.fBounds.isEmpty()) {
            return 0;  // Short buffer or bad bounds for non-empty region; report failure.
        }
        if (count == 0) {
            tmp.fRunHead = SkRegion_gRectRunHeadPtr;
        } else {
            int32_t ySpanCount, intervalCount;
            if (!buffer.readS32(&ySpanCount) ||
                !buffer.readS32(&intervalCount) ||
                buffer.available() < count * sizeof(int32_t)) {
                return 0;
            }
            if (!validate_run((const int32_t*)((const char*)storage + buffer.pos()), count,
                              tmp.fBounds, ySpanCount, intervalCount)) {
                return 0;  // invalid runs, don't even allocate
            }
            tmp.allocateRuns(count, ySpanCount, intervalCount);
            SkASSERT(tmp.isComplex());
            SkAssertResult(buffer.read(tmp.fRunHead->writable_runs(), count * sizeof(int32_t)));
        }
    }
    SkASSERT(tmp.isValid());
    SkASSERT(buffer.isValid());
    this->swap(tmp);
    return buffer.pos();
}

◆ set()

bool SkRegion::set ( const SkRegion & src )

inline

Sets SkRegion to src, and returns true if src bounds is not empty. This makes SkRegion and src identical by value. Internally, SkRegion and src share pointer values. The underlying SkRect array is copied when modified.

Creating a SkRegion copy is very efficient and never allocates memory. SkRegion are always copied by value from the interface; the underlying shared pointers are not exposed.

Parameters

src	SkRegion to copy

Returns: copy of src

Definition at line 121 of file SkRegion.h.

                                  {
        *this = src;
        return !this->isEmpty();
    }

◆ setEmpty()

bool SkRegion::setEmpty ( )

Constructs an empty SkRegion. SkRegion is set to empty bounds at (0, 0) with zero width and height. Always returns false.

Returns: false

example: https://fiddle.skia.org/c/@Region_setEmpty

Definition at line 185 of file SkRegion.cpp.

                        {
    this->freeRuns();
    fBounds.setEmpty();
    fRunHead = SkRegion_gEmptyRunHeadPtr;
    return false;
}

◆ setPath()

bool SkRegion::setPath	(	const SkPath &	path,
		const SkRegion &	clip
	)

Constructs SkRegion to match outline of path within clip. Returns false if constructed SkRegion is empty.

Constructed SkRegion draws the same pixels as path through clip when anti-aliasing is disabled.

Parameters

path	SkPath providing outline
clip	SkRegion containing path

Returns: true if constructed SkRegion is not empty

example: https://fiddle.skia.org/c/@Region_setPath

Definition at line 338 of file SkRegion_path.cpp.

                                                               {
    SkDEBUGCODE(SkRegionPriv::Validate(*this));
 
    if (clip.isEmpty() || !path.isFinite() || path.isEmpty()) {
        // This treats non-finite paths as empty as well, so this returns empty or 'clip' if
        // it's inverse-filled. If clip is also empty, path's fill type doesn't really matter
        // and this region ends up empty.
        return check_inverse_on_empty_return(this, path, clip);
    }
 
    // Our builder is very fragile, and can't be called with spans/rects out of Y->X order.
    // To ensure this, we only "fill" clipped to a rect (the clip's bounds), and if the
    // clip is more complex than that, we just post-intersect the result with the clip.
    const SkIRect clipBounds = clip.getBounds();
    if (clip.isComplex()) {
        if (!this->setPath(path, SkRegion(clipBounds))) {
            return false;
        }
        return this->op(clip, kIntersect_Op);
    }
 
    // SkScan::FillPath has limits on the coordinate range of the clipping SkRegion. If it's too
    // big, tile the clip bounds and union the pieces back together.
    if (SkScan::PathRequiresTiling(clipBounds)) {
        static constexpr int kTileSize = 32767 >> 1; // Limit so coords can fit into SkFixed (16.16)
        const SkIRect pathBounds = path.getBounds().roundOut();
 
        this->setEmpty();
 
        // Note: With large integers some intermediate calculations can overflow, but the
        // end results will still be in integer range. Using int64_t for the intermediate
        // values will handle this situation.
        for (int64_t top = clipBounds.fTop; top < clipBounds.fBottom; top += kTileSize) {
            int64_t bot = std::min(top + kTileSize, (int64_t)clipBounds.fBottom);
            for (int64_t left = clipBounds.fLeft; left < clipBounds.fRight; left += kTileSize) {
                int64_t right = std::min(left + kTileSize, (int64_t)clipBounds.fRight);
 
                SkIRect tileClipBounds = {(int)left, (int)top, (int)right, (int)bot};
                if (!SkIRect::Intersects(pathBounds, tileClipBounds)) {
                    continue;
                }
 
                // Shift coordinates so the top left is (0,0) during scan conversion and then
                // translate the SkRegion afterwards.
                tileClipBounds.offset(-left, -top);
                SkASSERT(!SkScan::PathRequiresTiling(tileClipBounds));
                SkRegion tile;
                tile.setPath(path.makeTransform(SkMatrix::Translate(-left, -top)),
                             SkRegion(tileClipBounds));
                tile.translate(left, top);
                this->op(tile, kUnion_Op);
            }
        }
        // During tiling we only applied the bounds of the tile, now that we have a full SkRegion,
        // apply the original clip.
        return this->op(clip, kIntersect_Op);
    }
 
    //  compute worst-case rgn-size for the path
    int pathTop, pathBot;
    int pathTransitions = count_path_runtype_values(path, &pathTop, &pathBot);
    if (0 == pathTransitions) {
        return check_inverse_on_empty_return(this, path, clip);
    }
 
    int clipTop, clipBot;
    int clipTransitions = clip.count_runtype_values(&clipTop, &clipBot);
 
    int top = std::max(pathTop, clipTop);
    int bot = std::min(pathBot, clipBot);
    if (top >= bot) {
        return check_inverse_on_empty_return(this, path, clip);
    }
 
    SkRgnBuilder builder;
 
    if (!builder.init(bot - top,
                      std::max(pathTransitions, clipTransitions),
                      path.isInverseFillType())) {
        // can't allocate working space, so return false
        return this->setEmpty();
    }
 
    SkScan::FillPath(path, clip, &builder);
    builder.done();
 
    int count = builder.computeRunCount();
    if (count == 0) {
        return this->setEmpty();
    } else if (count == kRectRegionRuns) {
        builder.copyToRect(&fBounds);
        this->setRect(fBounds);
    } else {
        SkRegion tmp;
 
        tmp.fRunHead = RunHead::Alloc(count);
        builder.copyToRgn(tmp.fRunHead->writable_runs());
        tmp.fRunHead->computeRunBounds(&tmp.fBounds);
        this->swap(tmp);
    }
    SkDEBUGCODE(SkRegionPriv::Validate(*this));
    return true;
}

◆ setRect()

bool SkRegion::setRect ( const SkIRect & rect )

Constructs a rectangular SkRegion matching the bounds of rect. If rect is empty, constructs empty and returns false.

Parameters

rect	bounds of constructed SkRegion

Returns: true if rect is not empty

example: https://fiddle.skia.org/c/@Region_setRect

Definition at line 192 of file SkRegion.cpp.

                                       {
    if (r.isEmpty() ||
        SkRegion_kRunTypeSentinel == r.right() ||
        SkRegion_kRunTypeSentinel == r.bottom()) {
        return this->setEmpty();
    }
    this->freeRuns();
    fBounds = r;
    fRunHead = SkRegion_gRectRunHeadPtr;
    return true;
}

◆ setRects()

bool SkRegion::setRects	(	const SkIRect	rects[],
		int	count
	)

Constructs SkRegion as the union of SkIRect in rects array. If count is zero, constructs empty SkRegion. Returns false if constructed SkRegion is empty.

May be faster than repeated calls to op().

Parameters

rects	array of SkIRect
count	array size

Returns: true if constructed SkRegion is not empty

example: https://fiddle.skia.org/c/@Region_setRects

Definition at line 657 of file SkRegion.cpp.

                                                        {
    if (0 == count) {
        this->setEmpty();
    } else {
        this->setRect(rects[0]);
        for (int i = 1; i < count; i++) {
            this->op(rects[i], kUnion_Op);
        }
    }
    return !this->isEmpty();
}

◆ setRegion()

bool SkRegion::setRegion ( const SkRegion & region )

Constructs a copy of an existing region. Makes two regions identical by value. Internally, region and the returned result share pointer values. The underlying SkRect array is copied when modified.

Creating a SkRegion copy is very efficient and never allocates memory. SkRegion are always copied by value from the interface; the underlying shared pointers are not exposed.

Parameters

region SkRegion to copy by value

Returns: SkRegion to copy by value

example: https://fiddle.skia.org/c/@Region_setRegion

Definition at line 204 of file SkRegion.cpp.

                                            {
    if (this != &src) {
        this->freeRuns();
 
        fBounds = src.fBounds;
        fRunHead = src.fRunHead;
        if (this->isComplex()) {
            fRunHead->fRefCnt++;
        }
    }
    return fRunHead != SkRegion_gEmptyRunHeadPtr;
}

◆ swap()

void SkRegion::swap ( SkRegion & other )

Exchanges SkIRect array of SkRegion and other. swap() internally exchanges pointers, so it is lightweight and does not allocate memory.

swap() usage has largely been replaced by operator=(const SkRegion& region). SkPath do not copy their content on assignment until they are written to, making assignment as efficient as swap().

Parameters

other operator=(const SkRegion& region) set

example: https://fiddle.skia.org/c/@Region_swap

Definition at line 170 of file SkRegion.cpp.

                                   {
    using std::swap;
    swap(fBounds, other.fBounds);
    swap(fRunHead, other.fRunHead);
}

◆ translate() [1/2]

void SkRegion::translate	(	int	dx,
		int	dy
	)

inline

Offsets SkRegion by ivector (dx, dy). Has no effect if SkRegion is empty.

Parameters

dx	x-axis offset
dy	y-axis offset

Definition at line 349 of file SkRegion.h.

349{ this->translate(dx, dy, this); }

SkRecords::dx

skia_private::AutoTArray< sk_sp< SkImageFilter > > filters TypedMatrix matrix TypedMatrix matrix SkScalar dx

Definition: SkRecords.h:208

◆ translate() [2/2]

void SkRegion::translate	(	int	dx,
		int	dy,
		SkRegion *	dst
	)		const

Offsets SkRegion by ivector (dx, dy), writing result to dst. SkRegion may be passed as dst parameter, translating SkRegion in place. Has no effect if dst is nullptr. If SkRegion is empty, sets dst to empty.

Parameters

dx	x-axis offset
dy	y-axis offset
dst	translated result

example: https://fiddle.skia.org/c/@Region_translate_2

Definition at line 596 of file SkRegion.cpp.

                                                            {
    SkDEBUGCODE(SkRegionPriv::Validate(*this));
 
    if (nullptr == dst) {
        return;
    }
    if (this->isEmpty()) {
        dst->setEmpty();
        return;
    }
    // pin dx and dy so we don't overflow our existing bounds
    dx = pin_offset_s32(fBounds.fLeft, fBounds.fRight, dx);
    dy = pin_offset_s32(fBounds.fTop, fBounds.fBottom, dy);
 
    if (this->isRect()) {
        dst->setRect(fBounds.makeOffset(dx, dy));
    } else {
        if (this == dst) {
            dst->fRunHead = dst->fRunHead->ensureWritable();
        } else {
            SkRegion    tmp;
            tmp.allocateRuns(*fRunHead);
            SkASSERT(tmp.isComplex());
            tmp.fBounds = fBounds;
            dst->swap(tmp);
        }
 
        dst->fBounds.offset(dx, dy);
 
        const RunType*  sruns = fRunHead->readonly_runs();
        RunType*        druns = dst->fRunHead->writable_runs();
 
        *druns++ = (SkRegion::RunType)(*sruns++ + dy);    // top
        for (;;) {
            int bottom = *sruns++;
            if (bottom == SkRegion_kRunTypeSentinel) {
                break;
            }
            *druns++ = (SkRegion::RunType)(bottom + dy);  // bottom;
            *druns++ = *sruns++;    // copy intervalCount;
            for (;;) {
                int x = *sruns++;
                if (x == SkRegion_kRunTypeSentinel) {
                    break;
                }
                *druns++ = (SkRegion::RunType)(x + dx);
                *druns++ = (SkRegion::RunType)(*sruns++ + dx);
            }
            *druns++ = SkRegion_kRunTypeSentinel;    // x sentinel
        }
        *druns++ = SkRegion_kRunTypeSentinel;    // y sentinel
 
        SkASSERT(sruns - fRunHead->readonly_runs() == fRunHead->fRunCount);
        SkASSERT(druns - dst->fRunHead->readonly_runs() == dst->fRunHead->fRunCount);
    }
 
    SkDEBUGCODE(SkRegionPriv::Validate(*this));
}

◆ writeToMemory()

size_t SkRegion::writeToMemory ( void * buffer ) const

Writes SkRegion to buffer, and returns number of bytes written. If buffer is nullptr, returns number number of bytes that would be written.

Parameters

buffer storage for binary data

Returns: size of SkRegion

example: https://fiddle.skia.org/c/@Region_writeToMemory

Definition at line 1149 of file SkRegion.cpp.

                                                  {
    if (nullptr == storage) {
        size_t size = sizeof(int32_t); // -1 (empty), 0 (rect), runCount
        if (!this->isEmpty()) {
            size += sizeof(fBounds);
            if (this->isComplex()) {
                size += 2 * sizeof(int32_t);    // ySpanCount + intervalCount
                size += fRunHead->fRunCount * sizeof(RunType);
            }
        }
        return size;
    }
 
    SkWBuffer   buffer(storage);
 
    if (this->isEmpty()) {
        buffer.write32(-1);
    } else {
        bool isRect = this->isRect();
 
        buffer.write32(isRect ? 0 : fRunHead->fRunCount);
        buffer.write(&fBounds, sizeof(fBounds));
 
        if (!isRect) {
            buffer.write32(fRunHead->getYSpanCount());
            buffer.write32(fRunHead->getIntervalCount());
            buffer.write(fRunHead->readonly_runs(),
                         fRunHead->fRunCount * sizeof(RunType));
        }
    }
    return buffer.pos();
}

Friends And Related Function Documentation

◆ Iterator

friend class Iterator

friend

Definition at line 677 of file SkRegion.h.

◆ RunHead

friend struct RunHead

friend

Definition at line 676 of file SkRegion.h.

◆ SkFlatRegion

friend class SkFlatRegion

friend

Definition at line 681 of file SkRegion.h.

◆ SkRegionPriv

friend class SkRegionPriv

friend

Definition at line 679 of file SkRegion.h.

◆ SkRgnBuilder

friend class SkRgnBuilder

friend

Definition at line 680 of file SkRegion.h.

◆ Spanerator

friend class Spanerator

friend

Definition at line 678 of file SkRegion.h.

Member Data Documentation

◆ kOpCnt

const int SkRegion::kOpCnt = kLastOp + 1

static

Definition at line 376 of file SkRegion.h.

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

third_party/skia/include/core/SkRegion.h
third_party/skia/src/core/SkRegion.cpp
third_party/skia/src/core/SkRegion_path.cpp

Classes

Public Types

Public Member Functions

Static Public Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ sk_is_trivially_relocatable

Member Enumeration Documentation

◆ Op

Constructor & Destructor Documentation

◆ SkRegion() [1/3]

◆ SkRegion() [2/3]

◆ SkRegion() [3/3]

◆ ~SkRegion()

Member Function Documentation

◆ computeRegionComplexity()

◆ contains() [1/3]

◆ contains() [2/3]

◆ contains() [3/3]

◆ getBoundaryPath()

◆ getBounds()

◆ intersects() [1/2]

◆ intersects() [2/2]

◆ isComplex()

◆ isEmpty()

◆ isRect()

◆ op() [1/5]

◆ op() [2/5]

◆ op() [3/5]

◆ op() [4/5]

◆ op() [5/5]

◆ operator!=()

◆ operator=()

◆ operator==()

◆ quickContains()

◆ quickReject() [1/2]

◆ quickReject() [2/2]

◆ readFromMemory()

◆ set()

◆ setEmpty()

◆ setPath()

◆ setRect()

◆ setRects()

◆ setRegion()

◆ swap()

◆ translate() [1/2]

◆ translate() [2/2]

◆ writeToMemory()

Friends And Related Function Documentation

◆ Iterator

◆ RunHead

◆ SkFlatRegion

◆ SkRegionPriv

◆ SkRgnBuilder

◆ Spanerator

Member Data Documentation

◆ kOpCnt