#include <rounding_radii.h>

Public Member Functions
constexpr bool	IsFinite () const

constexpr bool	AreAllCornersEmpty () const

constexpr bool	AreAllCornersSame (Scalar tolerance=kEhCloseEnough) const

RoundingRadii	Scaled (const Rect &bounds) const
	Returns a scaled copy of this object, ensuring that the sum of the corner radii on each side does not exceed the width or height of the given bounds. More...

constexpr RoundingRadii	operator* (Scalar scale)

constexpr bool	operator== (const RoundingRadii &rr) const

constexpr bool	operator!= (const RoundingRadii &rr) const

Static Public Member Functions
constexpr static RoundingRadii	MakeRadius (Scalar radius)

constexpr static RoundingRadii	MakeRadii (Size radii)

Public Attributes
Size	top_left

Size	top_right

Size	bottom_left

Size	bottom_right

Detailed Description

Definition at line 14 of file rounding_radii.h.

Member Function Documentation

◆ AreAllCornersEmpty()

constexpr bool impeller::RoundingRadii::AreAllCornersEmpty ( ) const

inlineconstexpr

Definition at line 35 of file rounding_radii.h.

                                             {
     return top_left.IsEmpty() &&     //
            top_right.IsEmpty() &&    //
            bottom_left.IsEmpty() &&  //
            bottom_right.IsEmpty();
   }

References bottom_left, bottom_right, impeller::TSize< T >::IsEmpty(), top_left, and top_right.

Referenced by impeller::RoundRect::IsRect(), Scaled(), and impeller::testing::TEST().

◆ AreAllCornersSame()

constexpr bool impeller::RoundingRadii::AreAllCornersSame ( Scalar tolerance = kEhCloseEnough ) const

inlineconstexpr

Definition at line 42 of file rounding_radii.h.

                                                                             {
     return ScalarNearlyEqual(top_left.width, top_right.width, tolerance) &&
            ScalarNearlyEqual(top_left.width, bottom_right.width, tolerance) &&
            ScalarNearlyEqual(top_left.width, bottom_left.width, tolerance) &&
            ScalarNearlyEqual(top_left.height, top_right.height, tolerance) &&
            ScalarNearlyEqual(top_left.height, bottom_right.height, tolerance) &&
            ScalarNearlyEqual(top_left.height, bottom_left.height, tolerance);
   }

References bottom_left, bottom_right, impeller::TSize< T >::height, impeller::ScalarNearlyEqual(), top_left, top_right, and impeller::TSize< T >::width.

Referenced by impeller::RoundRect::IsOval(), and impeller::testing::TEST().

◆ IsFinite()

constexpr bool impeller::RoundingRadii::IsFinite ( ) const

inlineconstexpr

Definition at line 28 of file rounding_radii.h.

                                   {
     return top_left.IsFinite() &&     //
            top_right.IsFinite() &&    //
            bottom_left.IsFinite() &&  //
            bottom_right.IsFinite();
   }

References bottom_left, bottom_right, impeller::TSize< T >::IsFinite(), top_left, and top_right.

Referenced by Scaled(), and impeller::testing::TEST().

◆ MakeRadii()

constexpr static RoundingRadii impeller::RoundingRadii::MakeRadii ( Size radii )

inlinestaticconstexpr

Definition at line 24 of file rounding_radii.h.

                                                        {
     return {radii, radii, radii, radii};
   }

Referenced by impeller::RoundRect::MakeOval(), impeller::RoundRect::MakeRectXY(), and impeller::testing::TEST().

◆ MakeRadius()

constexpr static RoundingRadii impeller::RoundingRadii::MakeRadius ( Scalar radius )

inlinestaticconstexpr

Definition at line 20 of file rounding_radii.h.

                                                            {
     return {Size(radius), Size(radius), Size(radius), Size(radius)};
   }

Referenced by impeller::RoundRect::MakeRectRadius(), and impeller::testing::TEST().

◆ operator!=()

constexpr bool impeller::RoundingRadii::operator!= ( const RoundingRadii & rr ) const

inlineconstexpr

Definition at line 76 of file rounding_radii.h.

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

◆ operator*()

constexpr RoundingRadii impeller::RoundingRadii::operator* ( Scalar scale )

inlineconstexpr

Definition at line 60 of file rounding_radii.h.

                                                          {
     return {
         .top_left = top_left * scale,
         .top_right = top_right * scale,
         .bottom_left = bottom_left * scale,
         .bottom_right = bottom_right * scale,
     };
   }

References bottom_left, bottom_right, scale, top_left, and top_right.

◆ operator==()

constexpr bool impeller::RoundingRadii::operator== ( const RoundingRadii & rr ) const

inlineconstexpr

Definition at line 69 of file rounding_radii.h.

                                                                          {
     return top_left == rr.top_left &&        //
            top_right == rr.top_right &&      //
            bottom_left == rr.bottom_left &&  //
            bottom_right == rr.bottom_right;
   }

References bottom_left, bottom_right, top_left, and top_right.

◆ Scaled()

RoundingRadii impeller::RoundingRadii::Scaled ( const Rect & bounds ) const

Returns a scaled copy of this object, ensuring that the sum of the corner radii on each side does not exceed the width or height of the given bounds.

See the Skia scaling implementation for more details.

Definition at line 26 of file rounding_radii.cc.

                                                                {
   Rect bounds = in_bounds.GetPositive();
   if (bounds.IsEmpty() ||  //
       AreAllCornersEmpty() || !IsFinite()) {
     // Normalize empty radii.
     return RoundingRadii();
   }
  
   // Copy the incoming radii so that we can work on normalizing them to the
   // particular rectangle they are paired with without disturbing the caller.
   RoundingRadii radii = *this;
  
   // If any corner is flat or has a negative value, normalize it to zeros
   // We do this first so that the unnecessary non-flat part of that radius
   // does not contribute to the global scaling below.
   NormalizeEmptyToZero(radii.top_left);
   NormalizeEmptyToZero(radii.top_right);
   NormalizeEmptyToZero(radii.bottom_left);
   NormalizeEmptyToZero(radii.bottom_right);
  
   // Now determine a global scale to apply to all of the radii to ensure
   // that none of the adjacent pairs of radius values sum to larger than
   // the corresponding dimension of the rectangle.
   Size size = bounds.GetSize();
   Scalar scale = 1.0f;
   // clang-format off
   AdjustScale(radii.top_left.width,    radii.top_right.width,     size.width,
               scale);
   AdjustScale(radii.bottom_left.width, radii.bottom_right.width,  size.width,
               scale);
   AdjustScale(radii.top_left.height,   radii.bottom_left.height,  size.height,
               scale);
   AdjustScale(radii.top_right.height,  radii.bottom_right.height, size.height,
               scale);
   // clang-format on
   if (scale < 1.0f) {
     radii = radii * scale;
   }
  
   return radii;
 }