#include <SkRect.h>

Inheritance diagram for SkRect:

Public Member Functions
bool	contains (SkScalar x, SkScalar y) const

bool	isEmpty () const

bool	isSorted () const

bool	isFinite () const

constexpr float	x () const

constexpr float	y () const

constexpr float	left () const

constexpr float	top () const

constexpr float	right () const

constexpr float	bottom () const

constexpr float	width () const

constexpr float	height () const

constexpr float	centerX () const

constexpr float	centerY () const

constexpr SkPoint	center () const

void	toQuad (SkPoint quad[4]) const

void	setEmpty ()

void	set (const SkIRect &src)

void	setLTRB (float left, float top, float right, float bottom)

void	setBounds (const SkPoint pts[], int count)

bool	setBoundsCheck (const SkPoint pts[], int count)

void	setBoundsNoCheck (const SkPoint pts[], int count)

void	set (const SkPoint &p0, const SkPoint &p1)

void	setXYWH (float x, float y, float width, float height)

void	setWH (float width, float height)

void	setIWH (int32_t width, int32_t height)

constexpr SkRect	makeOffset (float dx, float dy) const

constexpr SkRect	makeOffset (SkVector v) const

SkRect	makeInset (float dx, float dy) const

SkRect	makeOutset (float dx, float dy) const

void	offset (float dx, float dy)

void	offset (const SkPoint &delta)

void	offsetTo (float newX, float newY)

void	inset (float dx, float dy)

void	outset (float dx, float dy)

bool	intersect (const SkRect &r)

bool	intersect (const SkRect &a, const SkRect &b)

bool	intersects (const SkRect &r) const

void	join (const SkRect &r)

void	joinNonEmptyArg (const SkRect &r)

void	joinPossiblyEmptyRect (const SkRect &r)

bool	contains (float x, float y) const

bool	contains (const SkRect &r) const

bool	contains (const SkIRect &r) const

void	round (SkIRect *dst) const

void	roundOut (SkIRect *dst) const

void	roundOut (SkRect *dst) const

void	roundIn (SkIRect *dst) const

SkIRect	round () const

SkIRect	roundOut () const

SkIRect	roundIn () const

void	sort ()

SkRect	makeSorted () const

const float *	asScalars () const

void	dump (bool asHex) const

void	dump () const

void	dumpHex () const

Static Public Member Functions
static constexpr SkRect	MakeEmpty ()

static constexpr SkRect	MakeWH (float w, float h)

static SkRect	MakeIWH (int w, int h)

static constexpr SkRect	MakeSize (const SkSize &size)

static constexpr SkRect	MakeLTRB (float l, float t, float r, float b)

static constexpr SkRect	MakeXYWH (float x, float y, float w, float h)

static SkRect	Make (const SkISize &size)

static SkRect	Make (const SkIRect &irect)

static bool	Intersects (const SkRect &a, const SkRect &b)

Public Attributes
SkScalar	fLeft
	smaller x-axis bounds

SkScalar	fTop
	smaller y-axis bounds

SkScalar	fRight
	larger x-axis bounds

SkScalar	fBottom
	larger y-axis bounds

float	fLeft = 0
	smaller x-axis bounds

float	fTop = 0
	smaller y-axis bounds

float	fRight = 0
	larger x-axis bounds

float	fBottom = 0
	larger y-axis bounds

Friends
bool	operator== (const SkRect &a, const SkRect &b)

bool	operator!= (const SkRect &a, const SkRect &b)

Detailed Description

SkRect holds four float coordinates describing the upper and lower bounds of a rectangle. SkRect may be created from outer bounds or from position, width, and height. SkRect describes an area; if its right is less than or equal to its left, or if its bottom is less than or equal to its top, it is considered empty.

Definition at line 13 of file extension.cpp.

Member Function Documentation

◆ asScalars()

const float * SkRect::asScalars ( ) const

inline

Returns pointer to first float in SkRect, to treat it as an array with four entries.

Returns: pointer to fLeft

Definition at line 1340 of file SkRect.h.

1340{ return &fLeft; }

SkRect::fLeft

SkScalar fLeft

smaller x-axis bounds

Definition extension.cpp:14

◆ bottom()

constexpr float SkRect::bottom ( ) const

inlineconstexpr

Returns bottom edge of SkRect, if sorted. Call isEmpty() to see if SkRect may be invalid, and sort() to reverse fTop and fBottom if needed.

Returns: fBottom

Definition at line 755 of file SkRect.h.

755{ return fBottom; }

SkRect::fBottom

SkScalar fBottom

larger y-axis bounds

Definition extension.cpp:17

◆ center()

constexpr SkPoint SkRect::center ( ) const

inlineconstexpr

Returns the point this->centerX(), this->centerY().

Returns: rectangle center

Definition at line 792 of file SkRect.h.

792{ return {this->centerX(), this->centerY()}; }

SkRect::centerX

constexpr float centerX() const

Definition SkRect.h:776

SkRect::centerY

constexpr float centerY() const

Definition SkRect.h:785

◆ centerX()

constexpr float SkRect::centerX ( ) const

inlineconstexpr

Returns average of left edge and right edge. Result does not change if SkRect is sorted. Result may overflow to infinity if SkRect is far from the origin.

Returns: midpoint on x-axis

Definition at line 776 of file SkRect.h.

                                    {
        return sk_float_midpoint(fLeft, fRight);
    }

◆ centerY()

constexpr float SkRect::centerY ( ) const

inlineconstexpr

Returns average of top edge and bottom edge. Result does not change if SkRect is sorted.

Returns: midpoint on y-axis

Definition at line 785 of file SkRect.h.

                                    {
        return sk_float_midpoint(fTop, fBottom);
    }

◆ contains() [1/4]

bool SkRect::contains ( const SkIRect & r ) const

inline

Returns true if SkRect contains r. Returns false if SkRect is empty or r is empty.

SkRect contains r when SkRect area completely includes r area.

Parameters

r	SkIRect contained

Returns: true if all sides of SkRect are outside r

Definition at line 1215 of file SkRect.h.

                                          {
        // todo: can we eliminate the this->isEmpty check?
        return  !r.isEmpty() && !this->isEmpty() &&
                fLeft <= r.fLeft && fTop <= r.fTop &&
                fRight >= r.fRight && fBottom >= r.fBottom;
    }

◆ contains() [2/4]

bool SkRect::contains ( const SkRect & r ) const

inline

Returns true if SkRect contains r. Returns false if SkRect is empty or r is empty.

SkRect contains r when SkRect area completely includes r area.

Parameters

r	SkRect contained

Returns: true if all sides of SkRect are outside r

Definition at line 1200 of file SkRect.h.

                                         {
        // todo: can we eliminate the this->isEmpty check?
        return  !r.isEmpty() && !this->isEmpty() &&
                fLeft <= r.fLeft && fTop <= r.fTop &&
                fRight >= r.fRight && fBottom >= r.fBottom;
    }

◆ contains() [3/4]

bool SkRect::contains	(	float	x,
		float	y
	)		const

inline

Returns true if: fLeft <= x < fRight && fTop <= y < fBottom. Returns false if SkRect is empty.

Parameters

x	test SkPoint x-coordinate
y	test SkPoint y-coordinate

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

Definition at line 1188 of file SkRect.h.

                                          {
        return x >= fLeft && x < fRight && y >= fTop && y < fBottom;
    }

◆ contains() [4/4]

bool SkRect::contains	(	SkScalar	x,
		SkScalar	y
	)		const

inline

Definition at line 19 of file extension.cpp.

                                                {
        return x >= fLeft && x < fRight && y >= fTop && y < fBottom;
    }

◆ dump() [1/2]

void SkRect::dump ( ) const

inline

Writes text representation of SkRect to standard output. The representation may be directly compiled as C++ code. Floating point values are written with limited precision; it may not be possible to reconstruct original SkRect from output.

Definition at line 1356 of file SkRect.h.

1356{ this->dump(false); }

SkRect::dump

void dump() const

Definition SkRect.h:1356

◆ dump() [2/2]

void SkRect::dump ( bool asHex ) const

Writes text representation of SkRect to standard output. Set asHex to true to generate exact binary representations of floating point numbers.

Parameters

asHex true if SkScalar values are written as hexadecimal

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

Definition at line 152 of file SkRect.cpp.

                                  {
    SkScalarAsStringType asType = asHex ? kHex_SkScalarAsStringType : kDec_SkScalarAsStringType;
 
    SkString line;
    if (asHex) {
        SkString tmp;
        line.printf( "SkRect::MakeLTRB(%s, /* %f */\n", set_scalar(&tmp, fLeft, asType), fLeft);
        line.appendf("                 %s, /* %f */\n", set_scalar(&tmp, fTop, asType), fTop);
        line.appendf("                 %s, /* %f */\n", set_scalar(&tmp, fRight, asType), fRight);
        line.appendf("                 %s  /* %f */);", set_scalar(&tmp, fBottom, asType), fBottom);
    } else {
        SkString strL, strT, strR, strB;
        SkAppendScalarDec(&strL, fLeft);
        SkAppendScalarDec(&strT, fTop);
        SkAppendScalarDec(&strR, fRight);
        SkAppendScalarDec(&strB, fBottom);
        line.printf("SkRect::MakeLTRB(%s, %s, %s, %s);",
                    strL.c_str(), strT.c_str(), strR.c_str(), strB.c_str());
    }
    SkDebugf("%s\n", line.c_str());
}

◆ dumpHex()

void SkRect::dumpHex ( ) const

inline

Writes text representation of SkRect to standard output. The representation may be directly compiled as C++ code. Floating point values are written in hexadecimal to preserve their exact bit pattern. The output reconstructs the original SkRect.

Use instead of dump() when submitting

Definition at line 1365 of file SkRect.h.

1365{ this->dump(true); }

◆ height()

constexpr float SkRect::height ( ) const

inlineconstexpr

Returns span on the y-axis. This does not check if SkRect is sorted, or if result fits in 32-bit float; result may be negative or infinity.

Returns: fBottom minus fTop

Definition at line 769 of file SkRect.h.

769{ return fBottom - fTop; }

◆ inset()

void SkRect::inset	(	float	dx,
		float	dy
	)

inline

Insets SkRect by (dx, dy).

If dx is positive, makes SkRect narrower. If dx is negative, makes SkRect wider. If dy is positive, makes SkRect shorter. If dy is negative, makes SkRect taller.

Parameters

dx	added to fLeft and subtracted from fRight
dy	added to fTop and subtracted from fBottom

Definition at line 1060 of file SkRect.h.

                                    {
        fLeft   += dx;
        fTop    += dy;
        fRight  -= dx;
        fBottom -= dy;
    }

◆ intersect() [1/2]

bool SkRect::intersect	(	const SkRect &	a,
		const SkRect &	b
	)

Returns true if a intersects b, and sets SkRect to intersection. Returns false if a does not intersect b, and leaves SkRect unchanged.

Returns false if either a or b is empty, leaving SkRect unchanged.

Parameters

a	SkRect to intersect
b	SkRect to intersect

Returns: true if a and b have area in common

Definition at line 120 of file SkRect.cpp.

                                                       {
    CHECK_INTERSECT(a.fLeft, a.fTop, a.fRight, a.fBottom, b.fLeft, b.fTop, b.fRight, b.fBottom);
    this->setLTRB(L, T, R, B);
    return true;
}

◆ intersect() [2/2]

bool SkRect::intersect ( const SkRect & r )

Returns true if SkRect intersects r, and sets SkRect to intersection. Returns false if SkRect does not intersect r, and leaves SkRect unchanged.

Returns false if either r or SkRect is empty, leaving SkRect unchanged.

Parameters

r	limit of result

Returns: true if r and SkRect have area in common

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

Definition at line 114 of file SkRect.cpp.

                                      {
    CHECK_INTERSECT(r.fLeft, r.fTop, r.fRight, r.fBottom, fLeft, fTop, fRight, fBottom);
    this->setLTRB(L, T, R, B);
    return true;
}

◆ Intersects()

static bool SkRect::Intersects	(	const SkRect &	a,
		const SkRect &	b
	)

inlinestatic

Returns true if a intersects b. Returns false if either a or b is empty, or do not intersect.

Parameters

a	SkRect to intersect
b	SkRect to intersect

Returns: true if a and b have area in common

Definition at line 1133 of file SkRect.h.

                                                             {
        return Intersects(a.fLeft, a.fTop, a.fRight, a.fBottom,
                          b.fLeft, b.fTop, b.fRight, b.fBottom);
    }

◆ intersects()

bool SkRect::intersects ( const SkRect & r ) const

inline

Returns true if SkRect intersects r. Returns false if either r or SkRect is empty, or do not intersect.

Parameters

r	SkRect to intersect

Returns: true if r and SkRect have area in common

Definition at line 1121 of file SkRect.h.

                                           {
        return Intersects(fLeft, fTop, fRight, fBottom,
                          r.fLeft, r.fTop, r.fRight, r.fBottom);
    }

◆ isEmpty()

bool SkRect::isEmpty ( ) const

inline

Returns true if fLeft is equal to or greater than fRight, or if fTop is equal to or greater than fBottom. Call sort() to reverse rectangles with negative width() or height().

Returns: true if width() or height() are zero or negative

Definition at line 693 of file SkRect.h.

                         {
        // We write it as the NOT of a non-empty rect, so we will return true if any values
        // are NaN.
        return !(fLeft < fRight && fTop < fBottom);
    }

◆ isFinite()

bool SkRect::isFinite ( ) const

inline

Returns true if all values in the rectangle are finite.

Returns: true if no member is infinite or NaN

Definition at line 711 of file SkRect.h.

                          {
        return SkIsFinite(fLeft, fTop, fRight, fBottom);
    }

◆ isSorted()

bool SkRect::isSorted ( ) const

inline

Returns true if fLeft is equal to or less than fRight, or if fTop is equal to or less than fBottom. Call sort() to reverse rectangles with negative width() or height().

Returns: true if width() or height() are zero or positive

Definition at line 705 of file SkRect.h.

705{ return fLeft <= fRight && fTop <= fBottom; }

◆ join()

void SkRect::join ( const SkRect & r )

Sets SkRect to the union of itself and r.

Has no effect if r is empty. Otherwise, if SkRect is empty, sets SkRect to r.

Parameters

r	expansion SkRect

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

Definition at line 126 of file SkRect.cpp.

                                 {
    if (r.isEmpty()) {
        return;
    }
 
    if (this->isEmpty()) {
        *this = r;
    } else {
        fLeft   = std::min(fLeft, r.fLeft);
        fTop    = std::min(fTop, r.fTop);
        fRight  = std::max(fRight, r.fRight);
        fBottom = std::max(fBottom, r.fBottom);
    }
}

◆ joinNonEmptyArg()

void SkRect::joinNonEmptyArg ( const SkRect & r )

inline

Sets SkRect to the union of itself and r.

Asserts if r is empty and SK_DEBUG is defined. If SkRect is empty, sets SkRect to r.

May produce incorrect results if r is empty.

Parameters

r	expansion SkRect

Definition at line 1158 of file SkRect.h.

                                          {
        SkASSERT(!r.isEmpty());
        // if we are empty, just assign
        if (fLeft >= fRight || fTop >= fBottom) {
            *this = r;
        } else {
            this->joinPossiblyEmptyRect(r);
        }
    }

◆ joinPossiblyEmptyRect()

void SkRect::joinPossiblyEmptyRect ( const SkRect & r )

inline

Sets SkRect to the union of itself and the construction.

May produce incorrect results if SkRect or r is empty.

Parameters

r	expansion SkRect

Definition at line 1174 of file SkRect.h.

                                                {
        fLeft   = std::min(fLeft, r.left());
        fTop    = std::min(fTop, r.top());
        fRight  = std::max(fRight, r.right());
        fBottom = std::max(fBottom, r.bottom());
    }

◆ left()

constexpr float SkRect::left ( ) const

inlineconstexpr

Returns left edge of SkRect, if sorted. Call isSorted() to see if SkRect is valid. Call sort() to reverse fLeft and fRight if needed.

Returns: fLeft

Definition at line 734 of file SkRect.h.

734{ return fLeft; }

◆ Make() [1/2]

static SkRect SkRect::Make ( const SkIRect & irect )

inlinestatic

Returns constructed SkIRect set to irect, promoting integers to float. Does not validate input; fLeft may be greater than fRight, fTop may be greater than fBottom.

Parameters

irect integer unsorted bounds

Returns: irect members converted to float

Definition at line 680 of file SkRect.h.

                                                           {
        return {
            static_cast<float>(irect.fLeft), static_cast<float>(irect.fTop),
            static_cast<float>(irect.fRight), static_cast<float>(irect.fBottom)
        };
    }

◆ Make() [2/2]

static SkRect SkRect::Make ( const SkISize & size )

inlinestatic

Returns constructed SkIRect set to (0, 0, size.width(), size.height()). Does not validate input; size.width() or size.height() may be negative.

Parameters

size	integer values for SkRect width and height

Returns: bounds (0, 0, size.width(), size.height())

Definition at line 669 of file SkRect.h.

                                            {
        return MakeIWH(size.width(), size.height());
    }

◆ MakeEmpty()

static constexpr SkRect SkRect::MakeEmpty ( )

inlinestaticconstexpr

Returns constructed SkRect set to (0, 0, 0, 0). Many other rectangles are empty; if left is equal to or greater than right, or if top is equal to or greater than bottom. Setting all members to zero is a convenience, but does not designate a special empty rectangle.

Returns: bounds (0, 0, 0, 0)

Definition at line 595 of file SkRect.h.

                                                      {
        return SkRect{0, 0, 0, 0};
    }

◆ makeInset()

SkRect SkRect::makeInset	(	float	dx,
		float	dy
	)		const

inline

Returns SkRect, inset by (dx, dy).

If dx is negative, SkRect returned is wider. If dx is positive, SkRect returned is narrower. If dy is negative, SkRect returned is taller. If dy is positive, SkRect returned is shorter.

Parameters

dx	added to fLeft and subtracted from fRight
dy	added to fTop and subtracted from fBottom

Returns: SkRect inset symmetrically left and right, top and bottom

Definition at line 987 of file SkRect.h.

                                               {
        return MakeLTRB(fLeft + dx, fTop + dy, fRight - dx, fBottom - dy);
    }

◆ MakeIWH()

static SkRect SkRect::MakeIWH	(	int	w,
		int	h
	)

inlinestatic

Returns constructed SkRect set to integer values (0, 0, w, h). Does not validate input; w or h may be negative.

Use to avoid a compiler warning that input may lose precision when stored. Use SkIRect for an exact integer rectangle.

Parameters

w	integer width of constructed SkRect
h	integer height of constructed SkRect

Returns: bounds (0, 0, w, h)

Definition at line 623 of file SkRect.h.

                                                      {
        return {0, 0, static_cast<float>(w), static_cast<float>(h)};
    }

◆ MakeLTRB()

static constexpr SkRect SkRect::MakeLTRB	(	float	l,
		float	t,
		float	r,
		float	b
	)

inlinestaticconstexpr

Returns constructed SkRect set to (l, t, r, b). Does not sort input; SkRect may result in fLeft greater than fRight, or fTop greater than fBottom.

Parameters

l	float stored in fLeft
t	float stored in fTop
r	float stored in fRight
b	float stored in fBottom

Returns: bounds (l, t, r, b)

Definition at line 646 of file SkRect.h.

                                                                                       {
        return SkRect {l, t, r, b};
    }

◆ makeOffset() [1/2]

constexpr SkRect SkRect::makeOffset	(	float	dx,
		float	dy
	)		const

inlineconstexpr

Returns SkRect offset by (dx, dy).

If dx is negative, SkRect returned is moved to the left. If dx is positive, SkRect returned is moved to the right. If dy is negative, SkRect returned is moved upward. If dy is positive, SkRect returned is moved downward.

Parameters

dx	added to fLeft and fRight
dy	added to fTop and fBottom

Returns: SkRect offset on axes, with original width and height

Definition at line 965 of file SkRect.h.

                                                          {
        return MakeLTRB(fLeft + dx, fTop + dy, fRight + dx, fBottom + dy);
    }

◆ makeOffset() [2/2]

constexpr SkRect SkRect::makeOffset ( SkVector v ) const

inlineconstexpr

Returns SkRect offset by v.

Parameters

v	added to rect

Returns: SkRect offset on axes, with original width and height

Definition at line 974 of file SkRect.h.

974{ return this->makeOffset(v.x(), v.y()); }

SkPoint::y

constexpr float y() const

Definition SkPoint_impl.h:187

SkPoint::x

constexpr float x() const

Definition SkPoint_impl.h:181

SkRect::makeOffset

constexpr SkRect makeOffset(float dx, float dy) const

Definition SkRect.h:965

◆ makeOutset()

SkRect SkRect::makeOutset	(	float	dx,
		float	dy
	)		const

inline

Returns SkRect, outset by (dx, dy).

If dx is negative, SkRect returned is narrower. If dx is positive, SkRect returned is wider. If dy is negative, SkRect returned is shorter. If dy is positive, SkRect returned is taller.

Parameters

dx	subtracted to fLeft and added from fRight
dy	subtracted to fTop and added from fBottom

Returns: SkRect outset symmetrically left and right, top and bottom

Definition at line 1002 of file SkRect.h.

                                                {
        return MakeLTRB(fLeft - dx, fTop - dy, fRight + dx, fBottom + dy);
    }

◆ MakeSize()

static constexpr SkRect SkRect::MakeSize ( const SkSize & size )

inlinestaticconstexpr

Returns constructed SkRect set to (0, 0, size.width(), size.height()). Does not validate input; size.width() or size.height() may be negative.

Parameters

size	float values for SkRect width and height

Returns: bounds (0, 0, size.width(), size.height())

Definition at line 633 of file SkRect.h.

                                                                       {
        return SkRect{0, 0, size.fWidth, size.fHeight};
    }

◆ makeSorted()

SkRect SkRect::makeSorted ( ) const

inline

Returns SkRect with fLeft and fRight swapped if fLeft is greater than fRight; and with fTop and fBottom swapped if fTop is greater than fBottom. Result may be empty; and width() and height() will be zero or positive.

Returns: sorted SkRect

Definition at line 1330 of file SkRect.h.

                              {
        return MakeLTRB(std::min(fLeft, fRight), std::min(fTop, fBottom),
                        std::max(fLeft, fRight), std::max(fTop, fBottom));
    }

◆ MakeWH()

static constexpr SkRect SkRect::MakeWH	(	float	w,
		float	h
	)

inlinestaticconstexpr

Returns constructed SkRect set to float values (0, 0, w, h). Does not validate input; w or h may be negative.

Passing integer values may generate a compiler warning since SkRect cannot represent 32-bit integers exactly. Use SkIRect for an exact integer rectangle.

Parameters

w	float width of constructed SkRect
h	float height of constructed SkRect

Returns: bounds (0, 0, w, h)

Definition at line 609 of file SkRect.h.

                                                                   {
        return SkRect{0, 0, w, h};
    }

◆ MakeXYWH()

static constexpr SkRect SkRect::MakeXYWH	(	float	x,
		float	y,
		float	w,
		float	h
	)

inlinestaticconstexpr

Returns constructed SkRect set to (x, y, x + w, y + h). Does not validate input; w or h may be negative.

Parameters

x	stored in fLeft
y	stored in fTop
w	added to x and stored in fRight
h	added to y and stored in fBottom

Returns: bounds at (x, y) with width w and height h

Definition at line 659 of file SkRect.h.

                                                                                       {
        return SkRect {x, y, x + w, y + h};
    }

◆ offset() [1/2]

void SkRect::offset ( const SkPoint & delta )

inline

Offsets SkRect by adding delta.fX to fLeft, fRight; and by adding delta.fY to fTop, fBottom.

If delta.fX is negative, moves SkRect to the left. If delta.fX is positive, moves SkRect to the right. If delta.fY is negative, moves SkRect upward. If delta.fY is positive, moves SkRect downward.

Parameters

delta added to SkRect

Definition at line 1033 of file SkRect.h.

                                      {
        this->offset(delta.fX, delta.fY);
    }

◆ offset() [2/2]

void SkRect::offset	(	float	dx,
		float	dy
	)

inline

Offsets SkRect by adding dx to fLeft, fRight; and by adding dy to fTop, fBottom.

If dx is negative, moves SkRect to the left. If dx is positive, moves SkRect to the right. If dy is negative, moves SkRect upward. If dy is positive, moves SkRect downward.

Parameters

dx	offset added to fLeft and fRight
dy	offset added to fTop and fBottom

Definition at line 1016 of file SkRect.h.

                                    {
        fLeft   += dx;
        fTop    += dy;
        fRight  += dx;
        fBottom += dy;
    }

◆ offsetTo()

void SkRect::offsetTo	(	float	newX,
		float	newY
	)

inline

Offsets SkRect so that fLeft equals newX, and fTop equals newY. width and height are unchanged.

Parameters

newX	stored in fLeft, preserving width()
newY	stored in fTop, preserving height()

Definition at line 1043 of file SkRect.h.

                                          {
        fRight += newX - fLeft;
        fBottom += newY - fTop;
        fLeft = newX;
        fTop = newY;
    }

◆ outset()

void SkRect::outset	(	float	dx,
		float	dy
	)

inline

Outsets SkRect by (dx, dy).

If dx is positive, makes SkRect wider. If dx is negative, makes SkRect narrower. If dy is positive, makes SkRect taller. If dy is negative, makes SkRect shorter.

Parameters

dx	subtracted to fLeft and added from fRight
dy	subtracted to fTop and added from fBottom

Definition at line 1077 of file SkRect.h.

1077{ this->inset(-dx, -dy); }

SkRect::inset

void inset(float dx, float dy)

Definition SkRect.h:1060

◆ right()

constexpr float SkRect::right ( ) const

inlineconstexpr

Returns right edge of SkRect, if sorted. Call isSorted() to see if SkRect is valid. Call sort() to reverse fLeft and fRight if needed.

Returns: fRight

Definition at line 748 of file SkRect.h.

748{ return fRight; }

◆ round() [1/2]

SkIRect SkRect::round ( ) const

inline

Returns SkIRect by adding 0.5 and discarding the fractional portion of SkRect members, using (sk_float_round2int(fLeft), sk_float_round2int(fTop), sk_float_round2int(fRight), sk_float_round2int(fBottom)).

Returns: rounded SkIRect

Definition at line 1278 of file SkRect.h.

                          {
        SkIRect ir;
        this->round(&ir);
        return ir;
    }

◆ round() [2/2]

void SkRect::round ( SkIRect * dst ) const

inline

Sets SkIRect by adding 0.5 and discarding the fractional portion of SkRect members, using (sk_float_round2int(fLeft), sk_float_round2int(fTop), sk_float_round2int(fRight), sk_float_round2int(fBottom)).

Parameters

dst	storage for SkIRect

Definition at line 1228 of file SkRect.h.

                                   {
        SkASSERT(dst);
        dst->setLTRB(sk_float_round2int(fLeft),  sk_float_round2int(fTop),
                     sk_float_round2int(fRight), sk_float_round2int(fBottom));
    }

◆ roundIn() [1/2]

SkIRect SkRect::roundIn ( ) const

inline

Sets SkIRect by rounding up fLeft and fTop; and discarding the fractional portion of fRight and fBottom, using (sk_float_ceil2int(fLeft), sk_float_ceil2int(fTop), sk_float_floor2int(fRight), sk_float_floor2int(fBottom)).

Returns: rounded SkIRect

Definition at line 1303 of file SkRect.h.

                            {
        SkIRect ir;
        this->roundIn(&ir);
        return ir;
    }

◆ roundIn() [2/2]

void SkRect::roundIn ( SkIRect * dst ) const

inline

Sets SkRect by rounding up fLeft and fTop; and discarding the fractional portion of fRight and fBottom, using (sk_float_ceil2int(fLeft), sk_float_ceil2int(fTop), sk_float_floor2int(fRight), sk_float_floor2int(fBottom)).

Parameters

dst	storage for SkIRect

Definition at line 1266 of file SkRect.h.

                                     {
        SkASSERT(dst);
        dst->setLTRB(sk_float_ceil2int(fLeft),   sk_float_ceil2int(fTop),
                     sk_float_floor2int(fRight), sk_float_floor2int(fBottom));
    }

◆ roundOut() [1/3]

SkIRect SkRect::roundOut ( ) const

inline

Sets SkIRect by discarding the fractional portion of fLeft and fTop; and rounding up fRight and fBottom, using (sk_float_floor2int(fLeft), sk_float_floor2int(fTop), sk_float_ceil2int(fRight), sk_float_ceil2int(fBottom)).

Returns: rounded SkIRect

Definition at line 1291 of file SkRect.h.

                             {
        SkIRect ir;
        this->roundOut(&ir);
        return ir;
    }

◆ roundOut() [2/3]

void SkRect::roundOut ( SkIRect * dst ) const

inline

Sets SkIRect by discarding the fractional portion of fLeft and fTop; and rounding up fRight and fBottom, using (sk_float_floor2int(fLeft), sk_float_floor2int(fTop), sk_float_ceil2int(fRight), sk_float_ceil2int(fBottom)).

Parameters

dst	storage for SkIRect

Definition at line 1241 of file SkRect.h.

                                      {
        SkASSERT(dst);
        dst->setLTRB(sk_float_floor2int(fLeft), sk_float_floor2int(fTop),
                     sk_float_ceil2int(fRight), sk_float_ceil2int(fBottom));
    }

◆ roundOut() [3/3]

void SkRect::roundOut ( SkRect * dst ) const

inline

Sets SkRect by discarding the fractional portion of fLeft and fTop; and rounding up fRight and fBottom, using (std::floor(fLeft), std::floor(fTop), std::ceil(fRight), std::ceil(fBottom)).

Parameters

dst	storage for SkRect

Definition at line 1254 of file SkRect.h.

                                     {
        dst->setLTRB(std::floor(fLeft), std::floor(fTop),
                     std::ceil(fRight), std::ceil(fBottom));
    }

◆ set() [1/2]

void SkRect::set ( const SkIRect & src )

inline

Sets SkRect to src, promoting src members from integer to float. Very large values in src may lose precision.

Parameters

src	integer SkRect

Definition at line 849 of file SkRect.h.

                                 {
        fLeft   = src.fLeft;
        fTop    = src.fTop;
        fRight  = src.fRight;
        fBottom = src.fBottom;
    }

◆ set() [2/2]

void SkRect::set	(	const SkPoint &	p0,
		const SkPoint &	p1
	)

inline

Sets bounds to the smallest SkRect enclosing SkPoint p0 and p1. The result is sorted and may be empty. Does not check to see if values are finite.

Parameters

p0	corner to include
p1	corner to include

Definition at line 916 of file SkRect.h.

                                                   {
        fLeft =   std::min(p0.fX, p1.fX);
        fRight =  std::max(p0.fX, p1.fX);
        fTop =    std::min(p0.fY, p1.fY);
        fBottom = std::max(p0.fY, p1.fY);
    }

◆ setBounds()

void SkRect::setBounds	(	const SkPoint	pts[],
		int	count
	)

inline

Sets to bounds of SkPoint array with count entries. If count is zero or smaller, or if SkPoint array contains an infinity or NaN, sets to (0, 0, 0, 0).

Result is either empty or sorted: fLeft is less than or equal to fRight, and fTop is less than or equal to fBottom.

Parameters

pts	SkPoint array
count	entries in array

Definition at line 881 of file SkRect.h.

                                                   {
        (void)this->setBoundsCheck(pts, count);
    }

◆ setBoundsCheck()

bool SkRect::setBoundsCheck	(	const SkPoint	pts[],
		int	count
	)

Sets to bounds of SkPoint array with count entries. Returns false if count is zero or smaller, or if SkPoint array contains an infinity or NaN; in these cases sets SkRect to (0, 0, 0, 0).

Result is either empty or sorted: fLeft is less than or equal to fRight, and fTop is less than or equal to fBottom.

Parameters

pts	SkPoint array
count	entries in array

Returns: true if all SkPoint values are finite

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

Definition at line 61 of file SkRect.cpp.

                                                          {
    SkASSERT((pts && count > 0) || count == 0);
 
    if (count <= 0) {
        this->setEmpty();
        return true;
    }
 
    skvx::float4 min, max;
    if (count & 1) {
        min = max = skvx::float2::Load(pts).xyxy();
        pts   += 1;
        count -= 1;
    } else {
        min = max = skvx::float4::Load(pts);
        pts   += 2;
        count -= 2;
    }
 
    skvx::float4 accum = min * 0;
    while (count) {
        skvx::float4 xy = skvx::float4::Load(pts);
        accum = accum * xy;
        min = skvx::min(min, xy);
        max = skvx::max(max, xy);
        pts   += 2;
        count -= 2;
    }
 
    const bool all_finite = all(accum * 0 == 0);
    if (all_finite) {
        this->setLTRB(std::min(min[0], min[2]), std::min(min[1], min[3]),
                      std::max(max[0], max[2]), std::max(max[1], max[3]));
    } else {
        this->setEmpty();
    }
    return all_finite;
}

◆ setBoundsNoCheck()

void SkRect::setBoundsNoCheck	(	const SkPoint	pts[],
		int	count
	)

Sets to bounds of SkPoint pts array with count entries. If any SkPoint in pts contains infinity or NaN, all SkRect dimensions are set to NaN.

Parameters

pts	SkPoint array
count	entries in array

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

Definition at line 100 of file SkRect.cpp.

                                                            {
    if (!this->setBoundsCheck(pts, count)) {
        this->setLTRB(SK_FloatNaN, SK_FloatNaN, SK_FloatNaN, SK_FloatNaN);
    }
}

◆ setEmpty()

void SkRect::setEmpty ( )

inline

Sets SkRect to (0, 0, 0, 0).

Many other rectangles are empty; if left is equal to or greater than right, or if top is equal to or greater than bottom. Setting all members to zero is a convenience, but does not designate a special empty rectangle.

Definition at line 842 of file SkRect.h.

842{ *this = MakeEmpty(); }

SkRect::MakeEmpty

static constexpr SkRect MakeEmpty()

Definition SkRect.h:595

◆ setIWH()

void SkRect::setIWH	(	int32_t	width,
		int32_t	height
	)

inline

Definition at line 950 of file SkRect.h.

                                               {
        this->setWH(width, height);
    }

◆ setLTRB()

void SkRect::setLTRB	(	float	left,
		float	top,
		float	right,
		float	bottom
	)

inline

Sets SkRect to (left, top, right, bottom). left and right are not sorted; left is not necessarily less than right. top and bottom are not sorted; top is not necessarily less than bottom.

Parameters

left	stored in fLeft
top	stored in fTop
right	stored in fRight
bottom	stored in fBottom

Definition at line 865 of file SkRect.h.

                                                                   {
        fLeft   = left;
        fTop    = top;
        fRight  = right;
        fBottom = bottom;
    }

◆ setWH()

void SkRect::setWH	(	float	width,
		float	height
	)

inline

Sets SkRect to (0, 0, width, height). Does not validate input; width or height may be negative.

Parameters

width	stored in fRight
height	stored in fBottom

Definition at line 944 of file SkRect.h.

                                          {
        fLeft = 0;
        fTop = 0;
        fRight = width;
        fBottom = height;
    }

◆ setXYWH()

void SkRect::setXYWH	(	float	x,
		float	y,
		float	width,
		float	height
	)

inline

Sets SkRect to (x, y, x + width, y + height). Does not validate input; width or height may be negative.

Parameters

x	stored in fLeft
y	stored in fTop
width	added to x and stored in fRight
height	added to y and stored in fBottom

Definition at line 931 of file SkRect.h.

                                                              {
        fLeft = x;
        fTop = y;
        fRight = x + width;
        fBottom = y + height;
    }

◆ sort()

void SkRect::sort ( )

inline

Swaps fLeft and fRight if fLeft is greater than fRight; and swaps fTop and fBottom if fTop is greater than fBottom. Result may be empty; and width() and height() will be zero or positive.

Definition at line 1313 of file SkRect.h.

                {
        using std::swap;
        if (fLeft > fRight) {
            swap(fLeft, fRight);
        }
 
        if (fTop > fBottom) {
            swap(fTop, fBottom);
        }
    }

◆ top()

constexpr float SkRect::top ( ) const

inlineconstexpr

Returns top edge of SkRect, if sorted. Call isEmpty() to see if SkRect may be invalid, and sort() to reverse fTop and fBottom if needed.

Returns: fTop

Definition at line 741 of file SkRect.h.

741{ return fTop; }

◆ toQuad()

void SkRect::toQuad ( SkPoint quad[4] ) const

Returns four points in quad that enclose SkRect ordered as: top-left, top-right, bottom-right, bottom-left.

TODO: Consider adding parameter to control whether quad is clockwise or counterclockwise.

Parameters

quad	storage for corners of SkRect

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

Definition at line 50 of file SkRect.cpp.

                                         {
    SkASSERT(quad);
 
    quad[0].set(fLeft, fTop);
    quad[1].set(fRight, fTop);
    quad[2].set(fRight, fBottom);
    quad[3].set(fLeft, fBottom);
}

◆ width()

constexpr float SkRect::width ( ) const

inlineconstexpr

Returns span on the x-axis. This does not check if SkRect is sorted, or if result fits in 32-bit float; result may be negative or infinity.

Returns: fRight minus fLeft

Definition at line 762 of file SkRect.h.

762{ return fRight - fLeft; }

◆ x()

constexpr float SkRect::x ( ) const

inlineconstexpr

Returns left edge of SkRect, if sorted. Call isSorted() to see if SkRect is valid. Call sort() to reverse fLeft and fRight if needed.

Returns: fLeft

Definition at line 720 of file SkRect.h.

720{ return fLeft; }

◆ y()

constexpr float SkRect::y ( ) const

inlineconstexpr

Returns top edge of SkRect, if sorted. Call isEmpty() to see if SkRect may be invalid, and sort() to reverse fTop and fBottom if needed.

Returns: fTop

Definition at line 727 of file SkRect.h.

727{ return fTop; }

Friends And Related Symbol Documentation

◆ operator!=

bool operator!=	(	const SkRect &	a,
		const SkRect &	b
	)

friend

Returns true if any in a: fLeft, fTop, fRight, and fBottom; does not equal the corresponding members in b.

a and b are not equal if either contain NaN. a and b are equal if members contain zeroes with different signs.

Parameters

a	SkRect to compare
b	SkRect to compare

Returns: true if members are not equal

Definition at line 821 of file SkRect.h.

                                                             {
        return !(a == b);
    }

◆ operator==

bool operator==	(	const SkRect &	a,
		const SkRect &	b
	)

friend

Returns true if all members in a: fLeft, fTop, fRight, and fBottom; are equal to the corresponding members in b.

a and b are not equal if either contain NaN. a and b are equal if members contain zeroes with different signs.

Parameters

a	SkRect to compare
b	SkRect to compare

Returns: true if members are equal

Definition at line 804 of file SkRect.h.

                                                             {
        return a.fLeft == b.fLeft &&
               a.fTop == b.fTop &&
               a.fRight == b.fRight &&
               a.fBottom == b.fBottom;
    }

Member Data Documentation

◆ fBottom [1/2]

SkScalar SkRect::fBottom

larger y-axis bounds

Definition at line 17 of file extension.cpp.

◆ fBottom [2/2]

float SkRect::fBottom = 0

larger y-axis bounds

Definition at line 586 of file SkRect.h.

◆ fLeft [1/2]

SkScalar SkRect::fLeft

smaller x-axis bounds

Definition at line 14 of file extension.cpp.

◆ fLeft [2/2]

float SkRect::fLeft = 0

smaller x-axis bounds

Definition at line 583 of file SkRect.h.

◆ fRight [1/2]

SkScalar SkRect::fRight

larger x-axis bounds

Definition at line 16 of file extension.cpp.

◆ fRight [2/2]

float SkRect::fRight = 0

larger x-axis bounds

Definition at line 585 of file SkRect.h.

◆ fTop [1/2]

SkScalar SkRect::fTop

smaller y-axis bounds

Definition at line 15 of file extension.cpp.

◆ fTop [2/2]

float SkRect::fTop = 0

smaller y-axis bounds

Definition at line 584 of file SkRect.h.

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

third_party/skia/experimental/tskit/bindings/extension.cpp
third_party/skia/include/core/SkRect.h
third_party/skia/src/core/SkRect.cpp

Public Member Functions

Static Public Member Functions

Public Attributes

Friends

Detailed Description

Member Function Documentation

◆ asScalars()

◆ bottom()

◆ center()

◆ centerX()

◆ centerY()

◆ contains() [1/4]

◆ contains() [2/4]

◆ contains() [3/4]

◆ contains() [4/4]

◆ dump() [1/2]

◆ dump() [2/2]

◆ dumpHex()

◆ height()

◆ inset()

◆ intersect() [1/2]

◆ intersect() [2/2]

◆ Intersects()

◆ intersects()

◆ isEmpty()

◆ isFinite()

◆ isSorted()

◆ join()

◆ joinNonEmptyArg()

◆ joinPossiblyEmptyRect()

◆ left()

◆ Make() [1/2]

◆ Make() [2/2]

◆ MakeEmpty()

◆ makeInset()

◆ MakeIWH()

◆ MakeLTRB()

◆ makeOffset() [1/2]

◆ makeOffset() [2/2]

◆ makeOutset()

◆ MakeSize()

◆ makeSorted()

◆ MakeWH()

◆ MakeXYWH()

◆ offset() [1/2]

◆ offset() [2/2]

◆ offsetTo()

◆ outset()

◆ right()

◆ round() [1/2]

◆ round() [2/2]

◆ roundIn() [1/2]

◆ roundIn() [2/2]

◆ roundOut() [1/3]

◆ roundOut() [2/3]

◆ roundOut() [3/3]

◆ set() [1/2]

◆ set() [2/2]

◆ setBounds()

◆ setBoundsCheck()

◆ setBoundsNoCheck()

◆ setEmpty()

◆ setIWH()

◆ setLTRB()

◆ setWH()

◆ setXYWH()

◆ sort()

◆ top()

◆ toQuad()

◆ width()

◆ x()

◆ y()

Friends And Related Symbol Documentation

◆ operator!=

◆ operator==

Member Data Documentation

◆ fBottom [1/2]

◆ fBottom [2/2]

◆ fLeft [1/2]

◆ fLeft [2/2]