blob: a96237cdc53146f6eb38cac1b546ab0859936fd5 [file] [log] [blame]
#Topic RRect
#Alias Round_Rect ##
#Alias RRect_Reference ##
#Class SkRRect
#Private
Path forward:
core work
add contains(SkRect&) - for clip stack
add contains(SkRRect&) - for clip stack
add heart rect computation (max rect inside RR)
add 9patch rect computation
add growToInclude(SkPath&)
analysis
use growToInclude to fit skp round rects & generate stats (RRs vs. real paths)
check on # of rectorus's the RRs could handle
rendering work
update SkPath.addRRect() to only use quads
add GM and bench
further out
detect and triangulate RRectorii rather than falling back to SW in Ganesh
##
The SkRRect class represents a rounded rect with a potentially different
radii for each corner. It does not have a constructor so must be
initialized with one of the initialization functions (e.g., setEmpty,
setRectRadii, etc.)
This class allows implementing CSS properties that describe rounded corners.
A rectangle may have up to eight radii, one for each axis on each of its four
corners.
If either corner's radii are zero, the corner is square.
Negative radii are treated as zero.
If corner curves overlap, they are proportionally reduced to fit.
#Subtopic Overview
#Populate
##
#Subtopic Constructor
#Populate
##
#Subtopic Operator
#Populate
##
#Subtopic Member_Function
#Populate
##
# ------------------------------------------------------------------------------
#Method SkRRect()
#In Constructor
#Line # creates with zeroed bounds and corner radii ##
Initializes bounds at (0, 0), the origin, with zero width and height.
Initializes corner radii to (0, 0), and sets type of kEmpty_Type.
#Return empty Round_Rect ##
#Example
#Height 60
SkRRect rrect;
SkPaint p;
p.setStyle(SkPaint::kStroke_Style);
p.setStrokeWidth(10);
canvas->drawRRect(rrect, p);
rrect.setRect({10, 10, 100, 50});
canvas->drawRRect(rrect, p);
##
#SeeAlso setEmpty isEmpty
#Method ##
# ------------------------------------------------------------------------------
#Method SkRRect(const SkRRect& rrect)
#In Constructor
#Line # copies bounds and corner radii ##
Initializes to copy of rrect bounds and corner radii.
#Param rrect bounds and corner to copy ##
#Return copy of rrect ##
#Bug 8115
#Example
SkRRect rrect = SkRRect::MakeRect({10, 10, 100, 50});
SkRRect rrect2(rrect);
rrect2.inset(20, 20);
SkPaint p;
p.setStyle(SkPaint::kStroke_Style);
p.setStrokeWidth(10);
canvas->drawRRect(rrect, p);
canvas->drawRRect(rrect2, p);
##
#SeeAlso operator=(const SkRRect& rrect) MakeRect
#Method ##
# ------------------------------------------------------------------------------
#Method SkRRect& operator=(const SkRRect& rrect)
#In Operator
#Line # copies bounds and corner radii ##
Copies rrect bounds and corner radii.
#Param rrect bounds and corner to copy ##
#Return copy of rrect ##
#Example
SkRRect rrect = SkRRect::MakeRect({40, 40, 100, 70});
SkRRect rrect2 = rrect;
rrect2.inset(-20, -20);
SkPaint p;
p.setStyle(SkPaint::kStroke_Style);
p.setStrokeWidth(10);
canvas->drawRRect(rrect, p);
canvas->drawRRect(rrect2, p);
##
#SeeAlso SkRRect(const SkRRect& rrect) MakeRect
#Method ##
# ------------------------------------------------------------------------------
#Subtopic Type
#Line # specialization of Round_Rect geometry ##
#PhraseDef list_of_rrect_types
kEmpty_Type, kRect_Type, kOval_Type, kSimple_Type, kNinePatch_Type,
kComplex_Type
##
#Enum Type
#Line # specialization of Round_Rect geometry ##
#Code
enum Type {
kEmpty_Type,
kRect_Type,
kOval_Type,
kSimple_Type,
kNinePatch_Type,
kComplex_Type,
kLastType = kComplex_Type,
};
##
Type describes possible specializations of Round_Rect. Each Type is
exclusive; a Round_Rect may only have one type.
The enum members become progressively less restrictive; larger values of
Type have more degrees of freedom than smaller values.
#Const kEmpty_Type
#Line # zero width or height ##
Round_Rect has zero width or height. All radii are zero.
##
#Const kRect_Type
#Line # non-zero width and height, and zeroed radii ##
Round_Rect has width and height. All radii are zero.
##
#Const kOval_Type
#Line # non-zero width and height filled with radii ##
Round_Rect has width and height. All four x-radii are equal,
and at least half the width. All four y-radii are equal,
and at least half the height.
##
#Const kSimple_Type
#Line # non-zero width and height with equal radii ##
Round_Rect has width and height. All four x-radii are equal and
greater than zero, and all four y-radii are equal and greater than
zero. Either x-radii are less than half the width, or y-radii is
less than half the height, or both.
##
#Const kNinePatch_Type
#Line # non-zero width and height with axis-aligned radii ##
Round_Rect has width and height. Left x-radii are equal, top
y-radii are equal, right x-radii are equal, and bottom y-radii
are equal. The radii do not describe a rect, oval, or simple type.
The centers of the corner ellipses form an axis-aligned rectangle
that divides the Round_Rect into nine rectangular patches; an
interior rectangle, four edges, and four corners.
##
#Const kComplex_Type
#Line # non-zero width and height with arbitrary radii ##
both radii are non-zero.
##
#Const kLastType = kComplex_Type
#Line # largest Type value ##
##
#Example
#Height 128
struct Radii { SkVector data[4]; };
auto drawRRectType = [=](const SkRect& rect, const Radii& radii) {
SkRRect rrect;
rrect.setRectRadii(rect, radii.data);
SkPaint paint;
paint.setAntiAlias(true);
const char* typeStr[] = { "empty", "rect", "oval", "simple", "nine patch", "complex" };
paint.setTextAlign(SkPaint::kCenter_Align);
canvas->drawString(typeStr[(int) rrect.type()], rect.centerX(), rect.bottom() + 20, paint);
paint.setStyle(SkPaint::kStroke_Style);
canvas->drawRRect(rrect, paint);
};
drawRRectType({ 45, 30, 45, 30}, {{{ 5, 5}, { 5, 5}, { 5, 5}, { 5, 5}}});
drawRRectType({ 90, 10, 140, 30}, {{{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}}});
drawRRectType({160, 10, 210, 30}, {{{25, 10}, {25, 10}, {25, 10}, {25, 10}}});
drawRRectType({ 20, 80, 70, 100}, {{{ 5, 5}, { 5, 5}, { 5, 5}, { 5, 5}}});
drawRRectType({ 90, 80, 140, 100}, {{{ 5, 5}, {10, 5}, {10, 5}, { 5, 5}}});
drawRRectType({160, 80, 210, 100}, {{{ 5, 5}, {10, 5}, { 5, 5}, { 5, 5}}});
##
#SeeAlso Rect Path
#Enum ##
# ------------------------------------------------------------------------------
#Method Type getType() const
#In Property
#Line # returns Type ##
Returns Type, one of: #list_of_rrect_types#.
#Return Type ##
#Example
#Description
rrect2 is not a Rect; inset() has made it empty.
##
SkRRect rrect = SkRRect::MakeRect({10, 10, 100, 50});
SkRRect rrect2(rrect);
rrect2.inset(20, 20);
SkPaint p;
p.setStyle(SkPaint::kStroke_Style);
p.setStrokeWidth(10);
std::string str("Type ");
str += SkRRect::kRect_Type == rrect2.getType() ? "=" : "!";
str += "= SkRRect::kRect_Type";
canvas->drawString(str.c_str(), 20, 80, SkPaint());
canvas->drawRRect(rrect2, p);
##
#SeeAlso Type type
#Method ##
# ------------------------------------------------------------------------------
#Method Type type() const
#In Property
#Line # returns Type ##
Returns Type, one of: #list_of_rrect_types#.
#Return Type ##
#Example
#Description
inset() has made rrect2 empty.
##
SkRRect rrect = SkRRect::MakeRect({10, 10, 100, 50});
SkRRect rrect2(rrect);
rrect2.inset(20, 20);
SkPaint p;
p.setStyle(SkPaint::kStroke_Style);
p.setStrokeWidth(10);
std::string str("Type ");
str += SkRRect::kEmpty_Type == rrect2.type() ? "=" : "!";
str += "= SkRRect::kEmpty_Type";
canvas->drawString(str.c_str(), 20, 80, SkPaint());
canvas->drawRRect(rrect2, p);
##
#SeeAlso Type getType
#Method ##
#Subtopic Type ##
# ------------------------------------------------------------------------------
#Method inline bool isEmpty() const
#In Property
#Line # returns true if width or height are zero ##
Returns true if rect().fLeft is equal to rect().fRight, or if rect().fTop is equal
to rect().fBottom.
#Return true if width() or height() are zero ##
#Example
#Height 100
SkPaint paint;
paint.setAntiAlias(true);
paint.setTextAlign(SkPaint::kCenter_Align);
paint.setTextSize(16);
SkRRect rrect = SkRRect::MakeRectXY({30, 10, 100, 60}, 10, 5);
canvas->drawRRect(rrect, paint);
canvas->drawString(rrect.isEmpty() ? "empty" : "not empty", 64, 90, paint);
rrect.inset(40, 0);
canvas->translate(128, 0);
canvas->drawRRect(rrect, paint);
canvas->drawString(rrect.isEmpty() ? "empty" : "not empty", 64, 90, paint);
##
#SeeAlso SkRect::isEmpty height width
#Method ##
# ------------------------------------------------------------------------------
#Method inline bool isRect() const
#In Property
#Line # returns true if not empty, and one radius at each corner is zero ##
Returns true if not empty, and if either x or y radius at each corner is zero.
#Return true if not empty, and one radius at each corner is zero ##
#Example
#Height 100
SkPaint paint;
paint.setAntiAlias(true);
paint.setTextAlign(SkPaint::kCenter_Align);
paint.setTextSize(16);
SkRRect rrect = SkRRect::MakeRect({30, 10, 100, 60});
canvas->drawRRect(rrect, paint);
canvas->drawString(rrect.isRect() ? "rect" : "not rect", 64, 90, paint);
SkVector radii[] = {{10, 10}, {0, 0}, {0, 0}, {0, 0}};
rrect.setRectRadii(rrect.getBounds(), radii);
canvas->translate(128, 0);
canvas->drawRRect(rrect, paint);
canvas->drawString(rrect.isRect() ? "rect" : "not rect", 64, 90, paint);
##
#SeeAlso isEmpty radii
#Method ##
# ------------------------------------------------------------------------------
#Method inline bool isOval() const
#In Property
#Line # returns true if not empty, axes radii are equal, radii fill bounds ##
Returns true if not empty, if all x-axis radii are equal, if all y-axis radii
are equal, x-axis radii are at least half the width, and y-axis radii are at
least half the height.
#Return true if has identical geometry to Oval ##
#Example
#Height 100
#Description
The first radii are scaled down proportionately until both x-axis and y-axis fit
within the bounds. After scaling, x-axis radius is smaller than half the width;
left round rect is not an oval. The second radii are equal to half the
dimensions; right round rect is an oval.
##
SkPaint paint;
paint.setAntiAlias(true);
paint.setTextAlign(SkPaint::kCenter_Align);
paint.setTextSize(16);
SkRRect rrect = SkRRect::MakeRectXY({30, 10, 100, 60}, 40, 30);
canvas->drawRRect(rrect, paint);
canvas->drawString(rrect.isOval() ? "oval" : "not oval", 64, 90, paint);
rrect.setRectXY(rrect.getBounds(), 35, 25);
canvas->translate(128, 0);
canvas->drawRRect(rrect, paint);
canvas->drawString(rrect.isOval() ? "oval" : "not oval", 64, 90, paint);
##
#SeeAlso isEmpty isSimple SkCanvas::drawOval
#Method ##
# ------------------------------------------------------------------------------
#Method inline bool isSimple() const
#In Property
#Line # returns true if not empty, rect or oval; and axes radii are equal ##
Returns true if not empty, if all x-axis radii are equal but not zero,
if all y-axis radii are equal but not zero; and x-axis radius is less than half
width(), or y-axis radius is less than half height().
#Return true if not empty, rect or oval; and axes radii are equal ##
#Bug 8107
#Example
#Height 100
SkPaint paint;
paint.setAntiAlias(true);
paint.setTextAlign(SkPaint::kCenter_Align);
paint.setTextSize(16);
SkVector radii[] = {{40, 30}, {40, 30}, {40, 30}, {40, 30}};
SkRRect rrect;
rrect.setRectRadii({30, 10, 100, 60}, radii);
canvas->drawRRect(rrect, paint);
canvas->drawString(rrect.isSimple() ? "simple" : "not simple", 64, 90, paint);
radii[0].fX = 35;
rrect.setRectRadii(rrect.getBounds(), radii);
canvas->translate(128, 0);
canvas->drawRRect(rrect, paint);
canvas->drawString(rrect.isSimple() ? "simple" : "not simple", 64, 90, paint);
##
#SeeAlso isEmpty isRect isOval isNinePatch
#Method ##
# ------------------------------------------------------------------------------
#Method inline bool isNinePatch() const
#In Property
#Line # returns true if not empty, rect, oval or simple; and radii are axis-aligned ##
Returns true if isEmpty, isRect, isOval, and isSimple return false; and if
left x-axis radii are equal, right x-axis radii are equal, top y-axis radii are
equal, and bottom y-axis radii are equal.
#Return true if not empty, rect, oval or simple; and radii are axis-aligned ##
#Bug 8107
#Example
#Height 100
SkPaint paint;
paint.setAntiAlias(true);
paint.setTextAlign(SkPaint::kCenter_Align);
paint.setTextSize(16);
SkVector radii[] = {{20, 30}, {40, 30}, {40, 30}, {20, 30}};
SkRRect rrect;
rrect.setRectRadii({30, 10, 100, 60}, radii);
canvas->drawRRect(rrect, paint);
canvas->drawString(rrect.isNinePatch() ? "9 patch" : "not 9 patch", 64, 90, paint);
radii[0].fX = 35;
rrect.setRectRadii(rrect.getBounds(), radii);
canvas->translate(128, 0);
canvas->drawRRect(rrect, paint);
canvas->drawString(rrect.isNinePatch() ? "9 patch" : "not 9 patch", 64, 90, paint);
##
#SeeAlso isEmpty isRect isOval isSimple isComplex
#Method ##
# ------------------------------------------------------------------------------
#Method inline bool isComplex() const
#In Property
#Line # returns true if not empty, rect, oval, simple, or nine-patch ##
Returns true if isEmpty, isRect, isOval, isSimple, and isNinePatch return false.
If true: width and height are greater than zero, at least one corner radii are
both greater than zero; left x-axis radii are not equal, or right x-axis radii
are not equal, or top y-axis radii are not equal, or bottom y-axis radii are not
equal.
#Return true if not empty, rect, oval, simple, or nine-patch ##
#Example
SkPaint paint;
paint.setAntiAlias(true);
paint.setTextAlign(SkPaint::kCenter_Align);
paint.setTextSize(16);
SkVector radii[] = {{25, 30}, {40, 30}, {40, 30}, {20, 30}};
SkRRect rrect;
rrect.setRectRadii({30, 10, 100, 60}, radii);
canvas->drawRRect(rrect, paint);
canvas->drawString(rrect.isComplex() ? "complex" : "not complex", 64, 90, paint);
radii[0].fX = 20;
rrect.setRectRadii(rrect.getBounds(), radii);
canvas->translate(128, 0);
canvas->drawRRect(rrect, paint);
canvas->drawString(rrect.isComplex() ? "complex" : "not complex", 64, 90, paint);
##
#SeeAlso isEmpty isRect isOval isSimple isNinePatch
#Method ##
# ------------------------------------------------------------------------------
#Method SkScalar width() const
#In Property
#Line # returns span in x ##
Returns span on the x-axis. This does not check if result fits in 32-bit float;
result may be infinity.
#Return bounds().fRight minus bounds().fLeft ##
#Example
#Description
SkRRect::MakeRect sorts its input, so width() is always zero or larger.
##
SkRRect unsorted = SkRRect::MakeRect({ 15, 25, 10, 5 });
SkDebugf("unsorted width: %g\n", unsorted.width());
SkRRect large = SkRRect::MakeRect({ -FLT_MAX, 1, FLT_MAX, 2 });
SkDebugf("large width: %.0f\n", large.width());
#StdOut
unsorted width: 5
large width: inf
##
##
#SeeAlso SkRect::width height getBounds
#Method ##
# ------------------------------------------------------------------------------
#Method SkScalar height() const
#In Property
#Line # returns span in y ##
Returns span on the y-axis. This does not check if result fits in 32-bit float;
result may be infinity.
#Return bounds().fBottom minus bounds().fTop ##
#Example
#Description
SkRRect::MakeRect sorts its input, so height() is always zero or larger.
##
SkRRect unsorted = SkRRect::MakeRect({ 15, 25, 10, 20 });
SkDebugf("unsorted height: %g\n", unsorted.height());
SkRRect large = SkRRect::MakeRect({ 1, -FLT_MAX, 2, FLT_MAX });
SkDebugf("large height: %.0f\n", large.height());
#StdOut
unsorted height: 5
large height: inf
##
##
#SeeAlso SkRect.height width getBounds
#Method ##
# ------------------------------------------------------------------------------
#Method SkVector getSimpleRadii() const
#In Property
#Line # returns corner radii for simple types ##
Returns top-left corner x-radii. If type() returns kEmpty_Type, kRect_Type,
kOval_Type, or kSimple_Type, returns a value representative of all corner radii.
If type() returns kNinePatch_Type or kComplex_Type, at least one of the
remaining three corners has a different value.
#Return corner radii for simple types ##
#Example
auto drawDetails = [=](const SkRRect& rrect) {
SkPaint paint;
paint.setAntiAlias(true);
paint.setTextAlign(SkPaint::kCenter_Align);
paint.setTextSize(12);
canvas->drawRRect(rrect, paint);
SkVector corner = rrect.getSimpleRadii();
std::string label = "corner: " + std::to_string(corner.fX).substr(0, 3) + ", " +
std::to_string(corner.fY).substr(0, 3);
canvas->drawString(label.c_str(), 64, 90, paint);
canvas->translate(128, 0);
};
SkRRect rrect = SkRRect::MakeRect({30, 10, 100, 60});
drawDetails(rrect);
rrect.setRectXY(rrect.getBounds(), 5, 8);
drawDetails(rrect);
##
#SeeAlso radii getBounds getType isSimple
#Method ##
# ------------------------------------------------------------------------------
#Method void setEmpty()
#In Set
#Line # zeroes width, height, and corner radii ##
Sets bounds to zero width and height at (0, 0), the origin. Sets
corner radii to zero and sets type to kEmpty_Type.
#Example
#Description
Nothing blue is drawn because rrect is set to empty.
##
SkPaint paint;
SkRRect rrect = SkRRect::MakeRect({30, 10, 100, 60});
canvas->drawRRect(rrect, paint);
rrect.setEmpty();
paint.setColor(SK_ColorBLUE);
canvas->drawRRect(rrect, paint);
##
#SeeAlso MakeEmpty setRect
#Method ##
# ------------------------------------------------------------------------------
#Method void setRect(const SkRect& rect)
#In Set
#Line # sets rect bounds with zeroed corners ##
Sets bounds to sorted rect, and sets corner radii to zero.
If set bounds has width and height, and sets type to kRect_Type;
otherwise, sets type to kEmpty_Type.
#Param rect bounds to set ##
#Example
#Height 90
SkPaint paint;
SkRRect rrect = SkRRect::MakeRect({30, 10, 100, 60});
canvas->drawRRect(rrect, paint);
rrect.setRect({60, 30, 120, 80});
paint.setColor(SK_ColorBLUE);
canvas->drawRRect(rrect, paint);
##
#SeeAlso MakeRect setRectXY
#Method ##
# ------------------------------------------------------------------------------
#Method static SkRRect MakeEmpty()
#In Constructor
#Line # creates with zeroed bounds and corner radii ##
Initializes bounds at (0, 0), the origin, with zero width and height.
Initializes corner radii to (0, 0), and sets type of kEmpty_Type.
#Return empty Round_Rect ##
#Example
#Height 90
SkRRect rrect = SkRRect::MakeEmpty();
SkRRect rrect2(rrect);
rrect2.inset(-20, -20);
SkPaint p;
p.setStyle(SkPaint::kStroke_Style);
p.setStrokeWidth(10);
std::string str("Type ");
str += SkRRect::kEmpty_Type == rrect2.type() ? "=" : "!";
str += "= SkRRect::kEmpty_Type";
canvas->drawString(str.c_str(), 20, 80, SkPaint());
canvas->drawRRect(rrect2, p);
##
#SeeAlso SkRRect() SkRect::MakeEmpty
#Method ##
# ------------------------------------------------------------------------------
#Method static SkRRect MakeRect(const SkRect& r)
#In Constructor
#Line # copies bounds and zeroes corner radii ##
Initializes to copy of r bounds and zeroes corner radii.
#Param r bounds to copy ##
#Return copy of r ##
#Example
#Height 70
SkPaint paint;
SkRRect rrect = SkRRect::MakeRect({30, 10, 100, 60});
canvas->drawRRect(rrect, paint);
rrect.setOval(rrect.getBounds());
paint.setColor(SK_ColorBLUE);
canvas->drawRRect(rrect, paint);
##
#SeeAlso setRect MakeOval MakeRectXY
#Method ##
# ------------------------------------------------------------------------------
#Method static SkRRect MakeOval(const SkRect& oval)
#In Constructor
#Line # creates Oval to fit bounds ##
Sets bounds to oval, x-axis radii to half oval.width(), and all y-axis radii
to half oval.height(). If rect is empty, sets to kEmpty_Type.
Otherwise, sets to kOval_Type.
#Param oval bounds of Oval ##
#Return Oval ##
#Example
#Height 70
SkPaint paint;
SkRRect rrect = SkRRect::MakeOval({30, 10, 100, 60});
canvas->drawRRect(rrect, paint);
rrect.setRect(rrect.getBounds());
paint.setColor(SK_ColorBLUE);
paint.setBlendMode(SkBlendMode::kDifference);
canvas->drawRRect(rrect, paint);
##
#SeeAlso setOval MakeRect MakeRectXY
#Method ##
# ------------------------------------------------------------------------------
#Method static SkRRect MakeRectXY(const SkRect& rect, SkScalar xRad, SkScalar yRad)
#In Constructor
#Line # creates rounded rectangle ##
Sets to rounded rectangle with the same radii for all four corners.
If rect is empty, sets to kEmpty_Type.
Otherwise, if xRad and yRad are zero, sets to kRect_Type.
Otherwise, if xRad is at least half rect.width() and yRad is at least half
rect.height(), sets to kOval_Type.
Otherwise, sets to kSimple_Type.
#Param rect bounds of rounded rectangle ##
#Param xRad x-axis radius of corners ##
#Param yRad y-axis radius of corners ##
#Return rounded rectangle ##
#Example
#Height 70
SkPaint paint;
SkRRect rrect = SkRRect::MakeRectXY({30, 10, 100, 60}, 20, 20);
canvas->drawRRect(rrect, paint);
rrect.setRect(rrect.getBounds());
paint.setColor(SK_ColorBLUE);
paint.setBlendMode(SkBlendMode::kModulate);
canvas->drawRRect(rrect, paint);
##
#SeeAlso setRectXY
#Method ##
# ------------------------------------------------------------------------------
#Method void setOval(const SkRect& oval)
#In Set
#Line # replaces with Oval to fit bounds ##
Sets bounds to oval, x-axis radii to half oval.width(), and all y-axis radii
to half oval.height(). If rect is empty, sets to kEmpty_Type.
Otherwise, sets to kOval_Type.
#Param oval bounds of Oval ##
#Example
#Height 70
SkPaint paint;
SkRRect rrect = SkRRect::MakeRectXY({30, 10, 100, 60}, 20, 20);
canvas->drawRRect(rrect, paint);
rrect.setOval(rrect.getBounds());
paint.setColor(SK_ColorWHITE);
paint.setBlendMode(SkBlendMode::kExclusion);
canvas->drawRRect(rrect, paint);
##
#SeeAlso MakeOval
#Method ##
# ------------------------------------------------------------------------------
#Method void setRectXY(const SkRect& rect, SkScalar xRad, SkScalar yRad)
#In Set
#Line # replaces with rounded rectangle ##
Sets to rounded rectangle with the same radii for all four corners.
If rect is empty, sets to kEmpty_Type.
Otherwise, if xRad or yRad is zero, sets to kRect_Type.
Otherwise, if xRad is at least half rect.width() and yRad is at least half
rect.height(), sets to kOval_Type.
Otherwise, sets to kSimple_Type.
#Param rect bounds of rounded rectangle ##
#Param xRad x-axis radius of corners ##
#Param yRad y-axis radius of corners ##
#Example
#Height 70
SkPaint paint;
SkRRect rrect = SkRRect::MakeRectXY({30, 10, 100, 60}, 20, 20);
canvas->drawRRect(rrect, paint);
rrect.setRectXY(rrect.getBounds(), 5, 5);
paint.setColor(SK_ColorWHITE);
paint.setBlendMode(SkBlendMode::kExclusion);
canvas->drawRRect(rrect, paint);
##
#SeeAlso MakeRectXY SkPath::addRoundRect
#Method ##
# ------------------------------------------------------------------------------
#Method void setNinePatch(const SkRect& rect, SkScalar leftRad, SkScalar topRad,
SkScalar rightRad, SkScalar bottomRad)
#In Set
#Line # replaces with rounded rectangle ##
Sets bounds to rect. Sets radii to (leftRad, topRad), (rightRad, topRad),
(rightRad, bottomRad), (leftRad, bottomRad).
If rect is empty, sets to kEmpty_Type.
Otherwise, if leftRad and rightRad are zero, sets to kRect_Type.
Otherwise, if topRad and bottomRad are zero, sets to kRect_Type.
Otherwise, if leftRad and rightRad are equal and at least half rect.width(), and
topRad and bottomRad are equal at least half rect.height(), sets to kOval_Type.
Otherwise, if leftRad and rightRad are equal, and topRad and bottomRad are equal,
sets to kSimple_Type. Otherwise, sets to kNinePatch_Type.
Nine patch refers to the nine parts defined by the radii: one center rectangle,
four edge patches, and four corner patches.
#Param rect bounds of rounded rectangle ##
#Param leftRad left-top and left-bottom x-axis radius ##
#Param topRad left-top and right-top y-axis radius ##
#Param rightRad right-top and right-bottom x-axis radius ##
#Param bottomRad left-bottom and right-bottom y-axis radius ##
#Example
#Height 70
SkPaint paint;
paint.setAntiAlias(true);
SkRRect rrect;
rrect.setNinePatch({30, 10, 100, 60}, 10, 20, 20, 10);
canvas->drawRRect(rrect, paint);
paint.setColor(SK_ColorWHITE);
const SkRect r = rrect.getBounds();
canvas->drawLine(r.fLeft, r.fTop + rrect.radii(SkRRect::kUpperLeft_Corner).fY,
r.fRight, r.fTop + rrect.radii(SkRRect::kUpperRight_Corner).fY, paint);
canvas->drawLine(r.fLeft, r.fBottom - rrect.radii(SkRRect::kLowerLeft_Corner).fY,
r.fRight, r.fBottom - rrect.radii(SkRRect::kLowerRight_Corner).fY, paint);
canvas->drawLine(r.fLeft + rrect.radii(SkRRect::kUpperLeft_Corner).fX, r.fTop,
r.fLeft + rrect.radii(SkRRect::kLowerLeft_Corner).fX, r.fBottom, paint);
canvas->drawLine(r.fRight - rrect.radii(SkRRect::kUpperRight_Corner).fX, r.fTop,
r.fRight - rrect.radii(SkRRect::kLowerRight_Corner).fX, r.fBottom, paint);
##
#SeeAlso setRectRadii
#Method ##
# ------------------------------------------------------------------------------
#Method void setRectRadii(const SkRect& rect, const SkVector radii[4])
#In Set
#Line # replaces with rounded rectangle ##
Sets bounds to rect. Sets radii array for individual control of all for corners.
If rect is empty, sets to kEmpty_Type.
Otherwise, if one of each corner radii are zero, sets to kRect_Type.
Otherwise, if all x-axis radii are equal and at least half rect.width(), and
all y-axis radii are equal at least half rect.height(), sets to kOval_Type.
Otherwise, if all x-axis radii are equal, and all y-axis radii are equal,
sets to kSimple_Type. Otherwise, sets to kNinePatch_Type.
#Param rect bounds of rounded rectangle ##
#Param radii corner x-axis and y-axis radii ##
#Example
SkPaint paint;
paint.setStrokeWidth(15);
paint.setStrokeCap(SkPaint::kSquare_Cap);
paint.setAntiAlias(true);
float intervals[] = { 5, 21.75f };
paint.setStyle(SkPaint::kStroke_Style);
paint.setPathEffect(SkDashPathEffect::Make(intervals, SK_ARRAY_COUNT(intervals), 0));
SkPath path;
SkRRect rrect;
SkVector corners[] = {{15, 17}, {17, 19}, {19, 15}, {15, 15}};
rrect.setRectRadii({20, 20, 100, 100}, corners);
path.addRRect(rrect, SkPath::kCW_Direction);
canvas->drawPath(path, paint);
path.rewind();
path.addRRect(rrect, SkPath::kCCW_Direction, 1);
canvas->translate(120, 0);
canvas->drawPath(path, paint);
##
#SeeAlso setNinePatch SkPath::addRoundRect
#Method ##
# ------------------------------------------------------------------------------
#Enum Corner
#Line # corner radii order ##
#Code
enum Corner {
kUpperLeft_Corner,
kUpperRight_Corner,
kLowerRight_Corner,
kLowerLeft_Corner,
};
##
The radii are stored: top-left, top-right, bottom-right, bottom-left.
#Const kUpperLeft_Corner 0
#Line # index of top-left corner radii ##
##
#Const kUpperRight_Corner 1
#Line # index of top-right corner radii ##
##
#Const kLowerRight_Corner 2
#Line # index of bottom-right corner radii ##
##
#Const kLowerLeft_Corner 3
#Line # index of bottom-left corner radii ##
##
#Example
#Height 70
SkPaint paint;
paint.setAntiAlias(true);
SkRRect rrect;
SkVector corners[] = {{25, 17}, {17, 19}, {19, 15}, {15, 15}};
rrect.setRectRadii({30, 10, 100, 60}, corners);
canvas->drawRRect(rrect, paint);
paint.setColor(SK_ColorWHITE);
const SkRect r = rrect.getBounds();
canvas->drawLine(r.fLeft, r.fTop + rrect.radii(SkRRect::kUpperLeft_Corner).fY,
r.fRight, r.fTop + rrect.radii(SkRRect::kUpperRight_Corner).fY, paint);
canvas->drawLine(r.fLeft, r.fBottom - rrect.radii(SkRRect::kLowerLeft_Corner).fY,
r.fRight, r.fBottom - rrect.radii(SkRRect::kLowerRight_Corner).fY, paint);
canvas->drawLine(r.fLeft + rrect.radii(SkRRect::kUpperLeft_Corner).fX, r.fTop,
r.fLeft + rrect.radii(SkRRect::kLowerLeft_Corner).fX, r.fBottom, paint);
canvas->drawLine(r.fRight - rrect.radii(SkRRect::kUpperRight_Corner).fX, r.fTop,
r.fRight - rrect.radii(SkRRect::kLowerRight_Corner).fX, r.fBottom, paint);
##
#SeeAlso radii
#Enum ##
# ------------------------------------------------------------------------------
#Method const SkRect& rect() const
#In Property
#Line # returns bounds ##
Returns bounds. Bounds may have zero width or zero height. Bounds right is
greater than or equal to left; bounds bottom is greater than or equal to top.
Result is identical to getBounds.
#Return bounding box ##
#Example
for (SkScalar left : { SK_ScalarNaN, SK_ScalarInfinity, 100.f, 50.f, 25.f} ) {
SkRRect rrect1 = SkRRect::MakeRectXY({left, 20, 60, 220}, 50, 200);
SkDebugf("left bounds: (%g) %g\n", left, rrect1.rect().fLeft);
}
#StdOut
left bounds: (nan) 0
left bounds: (inf) 0
left bounds: (100) 60
left bounds: (50) 50
left bounds: (25) 25
##
##
#SeeAlso getBounds
#Method ##
# ------------------------------------------------------------------------------
#Method SkVector radii(Corner corner) const
#In Property
#Line # returns x-axis and y-axis radii for one corner ##
Returns Scalar pair for radius of curve on x-axis and y-axis for one corner.
Both radii may be zero. If not zero, both are positive and finite.
#Param corner one of: kUpperLeft_Corner, kUpperRight_Corner,
kLowerRight_Corner, kLowerLeft_Corner
##
#Return x-axis and y-axis radii for one corner ##
#Example
#Description
Finite values are scaled proportionately to fit; other values are set to zero.
Scaled values cannot be larger than 25, half the bounding rect width.
Small scaled values are halved to scale in proportion to the y-axis corner
radius, which is twice the bounds height.
##
for (SkScalar radiusX : { SK_ScalarNaN, SK_ScalarInfinity, 100.f, 50.f, 25.f} ) {
SkRRect rrect1 = SkRRect::MakeRectXY({10, 20, 60, 220}, radiusX, 200);
SkDebugf("left corner: (%g) %g\n", radiusX, rrect1.radii(SkRRect::kUpperLeft_Corner).fX);
}
#StdOut
left corner: (nan) 0
left corner: (inf) 0
left corner: (100) 25
left corner: (50) 25
left corner: (25) 12.5
##
##
#SeeAlso Corner
#Method ##
# ------------------------------------------------------------------------------
#Method const SkRect& getBounds() const
#In Property
#Line # returns bounds ##
Returns bounds. Bounds may have zero width or zero height. Bounds right is
greater than or equal to left; bounds bottom is greater than or equal to top.
Result is identical to rect().
#Return bounding box ##
#Example
#Height 120
SkPaint paint;
SkRRect rrect = SkRRect::MakeRectXY({20, 20, 220, 100}, 15, 15);
canvas->drawRRect(rrect, paint);
paint.setColor(SK_ColorWHITE);
rrect = SkRRect::MakeOval(rrect.getBounds());
canvas->drawRRect(rrect, paint);
##
#SeeAlso rect
#Method ##
# ------------------------------------------------------------------------------
#Method bool operator==(const SkRRect& a, const SkRRect& b)
#In Operator
#Line # returns true if members are equal ##
Returns true if bounds and radii in a are equal to bounds and radii in b.
a and b are not equal if either contain NaN. a and b are equal if members
contain zeroes width different signs.
#Param a Rect bounds and radii to compare ##
#Param b Rect bounds and radii to compare ##
#Return true if members are equal ##
#Example
SkRRect rrect1 = SkRRect::MakeRectXY({10, 20, 60, 220}, 50, 200);
SkRRect rrect2 = SkRRect::MakeRectXY(rrect1.rect(), 25, 100);
SkRRect rrect3 = SkRRect::MakeOval(rrect1.rect());
canvas->drawRRect(rrect1, SkPaint());
std::string str = "rrect1 " + std::string(rrect1 == rrect2 ? "=" : "!") + "= rrect2";
canvas->drawString(str.c_str(), 10, 240, SkPaint());
canvas->translate(70, 0);
canvas->drawRRect(rrect2, SkPaint());
canvas->translate(70, 0);
canvas->drawRRect(rrect3, SkPaint());
str = "rrect2 " + std::string(rrect2 == rrect3 ? "=" : "!") + "= rrect3";
canvas->drawString(str.c_str(), -20, 240, SkPaint());
##
#SeeAlso operator!=(const SkRRect& a, const SkRRect& b)
#Method ##
# ------------------------------------------------------------------------------
#Method bool operator!=(const SkRRect& a, const SkRRect& b)
#In Operator
#Line # returns true if members are unequal ##
Returns true if bounds and radii in a are not equal to bounds and radii in b.
a and b are not equal if either contain NaN. a and b are equal if members
contain zeroes width different signs.
#Param a Rect bounds and radii to compare ##
#Param b Rect bounds and radii to compare ##
#Return true if members are not equal ##
#Example
SkRRect rrect1 = SkRRect::MakeRectXY({10, 20, 60, 220}, 50, 100);
SkRRect rrect2 = SkRRect::MakeRectXY(rrect1.rect(), 50, 50);
SkRRect rrect3 = SkRRect::MakeOval(rrect1.rect());
canvas->drawRRect(rrect1, SkPaint());
std::string str = "rrect1 " + std::string(rrect1 == rrect2 ? "=" : "!") + "= rrect2";
canvas->drawString(str.c_str(), 10, 240, SkPaint());
canvas->translate(70, 0);
canvas->drawRRect(rrect2, SkPaint());
canvas->translate(70, 0);
canvas->drawRRect(rrect3, SkPaint());
str = "rrect2 " + std::string(rrect2 == rrect3 ? "=" : "!") + "= rrect3";
canvas->drawString(str.c_str(), -20, 240, SkPaint());
##
#SeeAlso operator==(const SkRRect& a, const SkRRect& b)
#Method ##
# ------------------------------------------------------------------------------
#Method void inset(SkScalar dx, SkScalar dy, SkRRect* dst) const
#In Inset_Outset_Offset
#Line # insets bounds and radii ##
Calls inset on the bounds, and adjust the radii to reflect what happens.
If the corner is sharp (no curvature), leave it alone,
otherwise we grow/shrink the radii by the amount of the inset. If a
given radius becomes negative, it is pinned to 0.
If the inset amount is larger than the width/height then the rrect collapses to
a degenerate line or point.
If the inset is sufficiently negative to cause the bounds to become infinite then
the result is a default initialized rrect.
It is valid for dst == this.
#Param dx added to rect().fLeft, and subtracted from rect().fRight ##
#Param dy added to rect().fTop, and subtracted from rect().fBottom ##
#Param dst insets bounds and radii ##
#Example
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
SkRRect rrect = SkRRect::MakeRectXY({100, 20, 140, 220}, 50, 100);
for (int index = 0; index < 25; ++index) {
canvas->drawRRect(rrect, paint);
rrect.inset(-3, 3, &rrect);
}
##
#SeeAlso outset offset makeOffset
#Method ##
# ------------------------------------------------------------------------------
#Method void inset(SkScalar dx, SkScalar dy)
#In Inset_Outset_Offset
#Line # insets bounds and radii ##
#Param dx added to rect().fLeft, and subtracted from rect().fRight ##
#Param dy added to rect().fTop, and subtracted from rect().fBottom ##
#Example
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
SkRRect rrect = SkRRect::MakeRectXY({10, 20, 180, 220}, 50, 100);
for (int index = 0; index < 25; ++index) {
canvas->drawRRect(rrect, paint);
rrect.inset(3, 3);
}
##
#SeeAlso outset offset makeOffset
#Method ##
# ------------------------------------------------------------------------------
#Method void outset(SkScalar dx, SkScalar dy, SkRRect* dst) const
#In Inset_Outset_Offset
#Line # outsets bounds and radii ##
Call outset on the bounds, and adjust the radii to reflect what happens
in stroking. If the corner is sharp (no curvature), leave it alone,
otherwise we grow/shrink the radii by the amount of the inset. If a
given radius becomes negative, it is pinned to 0.
It is valid for dst == this.
#Param dx subtracted from rect().fLeft, and added to rect().fRight ##
#Param dy subtracted from rect().fTop, and added to rect().fBottom ##
#Param dst outset bounds and radii ##
#Example
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
SkRRect rrect = SkRRect::MakeRectXY({100, 20, 140, 220}, 50, 100);
for (int index = 0; index < 25; ++index) {
canvas->drawRRect(rrect, paint);
rrect.outset(-3, 3, &rrect);
}
##
#SeeAlso inset offset makeOffset
#Method ##
# ------------------------------------------------------------------------------
#Method void outset(SkScalar dx, SkScalar dy)
#In Inset_Outset_Offset
#Line # outsets bounds and radii ##
#Param dx subtracted from rect().fLeft, and added to rect().fRight ##
#Param dy subtracted from rect().fTop, and added to rect().fBottom ##
#Example
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
SkRRect rrect = SkRRect::MakeRectXY({100, 20, 140, 220}, 50, 100);
for (int index = 0; index < 25; ++index) {
canvas->drawRRect(rrect, paint);
rrect.outset(3, 3);
}
##
#SeeAlso inset offset makeOffset
#Method ##
# ------------------------------------------------------------------------------
#Method void offset(SkScalar dx, SkScalar dy)
#In Inset_Outset_Offset
#Line # offsets bounds and radii ##
Translates the rrect by (dx, dy).
#Param dx offset added to rect().fLeft and rect().fRight ##
#Param dy offset added to rect().fTop and rect().fBottom ##
#Example
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
SkRRect rrect = SkRRect::MakeRectXY({100, 20, 140, 220}, 50, 100);
for (int index = 0; index < 25; ++index) {
canvas->drawRRect(rrect, paint);
rrect.offset(3, 3);
}
##
#SeeAlso makeOffset inset outset
#Method ##
# ------------------------------------------------------------------------------
#Method SkRRect SK_WARN_UNUSED_RESULT makeOffset(SkScalar dx, SkScalar dy) const
#In Inset_Outset_Offset
#Line # offsets bounds and radii ##
#Param dx offset added to rect().fLeft and rect().fRight ##
#Param dy offset added to rect().fTop and rect().fBottom ##
#Return Round_Rect bounds offset by (dx, dy), with unchanged corner radii ##
#Example
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
SkRRect rrect = SkRRect::MakeRectXY({100, 20, 140, 220}, 50, 100);
for (int index = 0; index < 25; ++index) {
canvas->drawRRect(rrect, paint);
rrect = rrect.makeOffset(-3, 3);
}
##
#SeeAlso offset inset outset
#Method ##
# ------------------------------------------------------------------------------
#Method bool contains(const SkRect& rect) const
#In Intersection
#Line # returns true if Rect is inside ##
Returns true if rect is inside the bounds and corner radii, and if
Round_Rect and rect are not empty.
#Param rect area tested for containment ##
#Return true if Round_Rect contains rect ##
#Example
// incomplete
##
#SeeAlso SkRect::contains
#Method ##
# ------------------------------------------------------------------------------
#Method bool isValid() const
#In Utility
#Line # incomplete ##
#Return incomplete ##
#Example
// incomplete
##
#SeeAlso incomplete
#Method ##
# ------------------------------------------------------------------------------
#Const kSizeInMemory 48
#Line # incomplete ##
#Example
// incomplete
##
#Const ##
# ------------------------------------------------------------------------------
#Method size_t writeToMemory(void* buffer) const
#In Utility
#Line # incomplete ##
Write the rrect into the specified buffer. This is guaranteed to always
write kSizeInMemory bytes, and that value is guaranteed to always be
a multiple of 4. Return kSizeInMemory.
#Param buffer incomplete ##
#Return incomplete ##
#Example
// incomplete
##
#SeeAlso incomplete
#Method ##
# ------------------------------------------------------------------------------
#Method size_t readFromMemory(const void* buffer, size_t length)
#In Utility
#Line # incomplete ##
Reads the rrect from the specified buffer.
If the specified buffer is large enough, this will read kSizeInMemory bytes,
and that value is guaranteed to always be a multiple of 4.
#Param buffer memory to read from
##
#Param length amount of memory available in the buffer
##
#Return number of bytes read (must be a multiple of 4) or
0 if there was not enough memory available
##
#Example
// incomplete
##
#SeeAlso incomplete
#Method ##
# ------------------------------------------------------------------------------
#Method bool transform(const SkMatrix& matrix, SkRRect* dst) const
#In Inset_Outset_Offset
#Line # scales and offsets into copy ##
Transforms by Round_Rect by matrix, storing result in dst.
Returns true if Round_Rect transformed can be represented by another Round_Rect.
Returns false if matrix contains transformations other than scale and translate.
Asserts in debug builds if Round_Rect equals dst.
#Param matrix SkMatrix specifying the transform ##
#Param dst SkRRect to store the result ##
#Return true if transformation succeeded.
##
#Example
// incomplete
##
#SeeAlso incomplete
#Method ##
# ------------------------------------------------------------------------------
#Method void dump(bool asHex) const
#In Utility
#Line # sends text representation to standard output ##
Writes text representation of Round_Rect to standard output.
Set asHex true to generate exact binary representations
of floating point numbers.
#Param asHex true if SkScalar values are written as hexadecimal ##
#Example
SkRRect rrect = SkRRect::MakeRect({6.f / 7, 2.f / 3, 6.f / 7, 2.f / 3});
for (bool dumpAsHex : { false, true } ) {
rrect.dump(dumpAsHex);
}
#StdOut
SkRect::MakeLTRB(0.857143f, 0.666667f, 0.857143f, 0.666667f);
const SkPoint corners[] = {
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
};
SkRect::MakeLTRB(SkBits2Float(0x3f5b6db7), /* 0.857143 */
SkBits2Float(0x3f2aaaab), /* 0.666667 */
SkBits2Float(0x3f5b6db7), /* 0.857143 */
SkBits2Float(0x3f2aaaab) /* 0.666667 */);
const SkPoint corners[] = {
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
};
##
##
#SeeAlso dumpHex SkRect::dump SkPath::dump SkPathMeasure::dump
#Method ##
# ------------------------------------------------------------------------------
#Method void dump() const
#In Utility
#Line # sends text representation using floats to standard output ##
Writes text representation of Round_Rect 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
Round_Rect from output.
#Example
SkRRect rrect = SkRRect::MakeRect({6.f / 7, 2.f / 3, 6.f / 7, 2.f / 3});
rrect.dump();
SkRect bounds = SkRect::MakeLTRB(0.857143f, 0.666667f, 0.857143f, 0.666667f);
const SkPoint corners[] = {
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
};
SkRRect copy;
copy.setRectRadii(bounds, corners);
SkDebugf("rrect is " "%s" "equal to copy\n", rrect == copy ? "" : "not ");
#StdOut
SkRect::MakeLTRB(0.857143f, 0.666667f, 0.857143f, 0.666667f);
const SkPoint corners[] = {
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
{ 0, 0 },
};
rrect is not equal to copy
##
##
#SeeAlso dumpHex SkRect::dump SkPath::dump SkPathMeasure::dump
#Method ##
# ------------------------------------------------------------------------------
#Method void dumpHex() const
#In Utility
#Line # sends text representation using hexadecimal to standard output ##
Writes text representation of Round_Rect 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 Round_Rect.
#Example
SkRRect rrect = SkRRect::MakeRect({6.f / 7, 2.f / 3, 6.f / 7, 2.f / 3});
rrect.dumpHex();
SkRect bounds = SkRect::MakeLTRB(SkBits2Float(0x3f5b6db7), /* 0.857143 */
SkBits2Float(0x3f2aaaab), /* 0.666667 */
SkBits2Float(0x3f5b6db7), /* 0.857143 */
SkBits2Float(0x3f2aaaab) /* 0.666667 */);
const SkPoint corners[] = {
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
};
SkRRect copy;
copy.setRectRadii(bounds, corners);
SkDebugf("rrect is " "%s" "equal to copy\n", rrect == copy ? "" : "not ");
#StdOut
SkRect::MakeLTRB(SkBits2Float(0x3f5b6db7), /* 0.857143 */
SkBits2Float(0x3f2aaaab), /* 0.666667 */
SkBits2Float(0x3f5b6db7), /* 0.857143 */
SkBits2Float(0x3f2aaaab) /* 0.666667 */);
const SkPoint corners[] = {
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
{ SkBits2Float(0x00000000), SkBits2Float(0x00000000) }, /* 0.000000 0.000000 */
};
rrect is equal to copy
##
##
#SeeAlso dump SkRect::dumpHex SkPath::dumpHex
#Method ##
#Class SkRRect ##
#Topic RRect ##