Flutter Impeller
impeller::TRect< T > Struct Template Reference

#include <rect.h>

Public Member Functions

constexpr TRect ()
 
constexpr bool operator== (const TRect &r) const
 
constexpr bool operator!= (const TRect &r) const
 
constexpr TRect Scale (Type scale) const
 
constexpr TRect Scale (Type scale_x, Type scale_y) const
 
constexpr TRect Scale (TPoint< T > scale) const
 
constexpr TRect Scale (TSize< T > scale) const
 
constexpr bool Contains (const TPoint< Type > &p) const
 Returns true iff the provided point |p| is inside the half-open interior of this rectangle. More...
 
constexpr bool ContainsInclusive (const TPoint< Type > &p) const
 Returns true iff the provided point |p| is inside the closed-range interior of this rectangle. More...
 
constexpr bool Contains (const TRect &o) const
 Returns true iff this rectangle is not empty and it also contains every point considered inside the provided rectangle |o| (as determined by |Contains(TPoint)|). More...
 
 IsFinite () const
 Returns true if all of the fields of this floating point rectangle are finite. More...
 
constexpr bool IsEmpty () const
 Returns true if either of the width or height are 0, negative, or NaN. More...
 
constexpr bool IsSquare () const
 Returns true if width and height are equal and neither is NaN. More...
 
constexpr bool IsMaximum () const
 
constexpr TPoint< Type > GetOrigin () const
 Returns the upper left corner of the rectangle as specified by the left/top or x/y values when it was constructed. More...
 
constexpr TSize< Type > GetSize () const
 Returns the size of the rectangle which may be negative in either width or height and may have been clipped to the maximum integer values for integer rects whose size overflows. More...
 
constexpr Type GetX () const
 Returns the X coordinate of the upper left corner, equivalent to |GetOrigin().x|. More...
 
constexpr Type GetY () const
 Returns the Y coordinate of the upper left corner, equivalent to |GetOrigin().y|. More...
 
constexpr Type GetWidth () const
 Returns the width of the rectangle, equivalent to |GetSize().width|. More...
 
constexpr Type GetHeight () const
 Returns the height of the rectangle, equivalent to |GetSize().height|. More...
 
constexpr auto GetLeft () const
 
constexpr auto GetTop () const
 
constexpr auto GetRight () const
 
constexpr auto GetBottom () const
 
constexpr TPoint< T > GetLeftTop () const
 
constexpr TPoint< T > GetRightTop () const
 
constexpr TPoint< T > GetLeftBottom () const
 
constexpr TPoint< T > GetRightBottom () const
 
constexpr T Area () const
 Get the area of the rectangle, equivalent to |GetSize().Area()|. More...
 
constexpr Point GetCenter () const
 Get the center point as a |Point|. More...
 
constexpr std::array< T, 4 > GetLTRB () const
 
constexpr std::array< T, 4 > GetXYWH () const
 Get the x, y coordinates of the origin and the width and height of the rectangle in an array. More...
 
constexpr TRect GetPositive () const
 Get a version of this rectangle that has a non-negative size. More...
 
constexpr std::array< TPoint< T >, 4 > GetPoints () const
 Get the points that represent the 4 corners of this rectangle in a Z order that is compatible with triangle strips or a set of all zero points if the rectangle is empty. The order is: Top left, top right, bottom left, bottom right. More...
 
constexpr std::array< TPoint< T >, 4 > GetTransformedPoints (const Matrix &transform) const
 
constexpr TRect TransformAndClipBounds (const Matrix &transform) const
 Creates a new bounding box that contains this transformed rectangle, clipped against the near clipping plane if necessary. More...
 
constexpr TRect TransformBounds (const Matrix &transform) const
 Creates a new bounding box that contains this transformed rectangle. More...
 
constexpr Matrix GetNormalizingTransform () const
 Constructs a Matrix that will map all points in the coordinate space of the rectangle into a new normalized coordinate space where the upper left corner of the rectangle maps to (0, 0) and the lower right corner of the rectangle maps to (1, 1). More...
 
constexpr TRect Union (const TRect &o) const
 
constexpr std::optional< TRectIntersection (const TRect &o) const
 
constexpr TRect IntersectionOrEmpty (const TRect &o) const
 
constexpr bool IntersectsWithRect (const TRect &o) const
 
constexpr std::optional< TRect< T > > Cutout (const TRect &o) const
 Returns the new boundary rectangle that would result from this rectangle being cut out by the specified rectangle. More...
 
constexpr TRect CutoutOrEmpty (const TRect &o) const
 
constexpr TRect< T > Shift (T dx, T dy) const
 Returns a new rectangle translated by the given offset. More...
 
constexpr TRect< T > Shift (TPoint< T > offset) const
 Returns a new rectangle translated by the given offset. More...
 
constexpr TRect< T > Expand (T left, T top, T right, T bottom) const
 Returns a rectangle with expanded edges. Negative expansion results in shrinking. More...
 
constexpr TRect< T > Expand (T amount) const
 Returns a rectangle with expanded edges in all directions. Negative expansion results in shrinking. More...
 
constexpr TRect< T > Expand (T horizontal_amount, T vertical_amount) const
 Returns a rectangle with expanded edges in all directions. Negative expansion results in shrinking. More...
 
constexpr TRect< T > Expand (TPoint< T > amount) const
 Returns a rectangle with expanded edges in all directions. Negative expansion results in shrinking. More...
 
constexpr TRect< T > Expand (TSize< T > amount) const
 Returns a rectangle with expanded edges in all directions. Negative expansion results in shrinking. More...
 
constexpr TRect< T > Project (TRect< T > source) const
 Returns a new rectangle that represents the projection of the source rectangle onto this rectangle. In other words, the source rectangle is redefined in terms of the coordinate space of this rectangle. More...
 
 RoundOut (const TRect< U > &r)
 
 RoundIn (const TRect< U > &r)
 
 Round (const TRect< U > &r)
 

Static Public Member Functions

constexpr static TRect MakeLTRB (Type left, Type top, Type right, Type bottom)
 
constexpr static TRect MakeXYWH (Type x, Type y, Type width, Type height)
 
constexpr static TRect MakeWH (Type width, Type height)
 
constexpr static TRect MakeOriginSize (const TPoint< Type > &origin, const TSize< Type > &size)
 
template<class U >
constexpr static TRect MakeSize (const TSize< U > &size)
 
template<class U , class FT = T>
constexpr static std::enable_if_t< std::is_floating_point_v< FT >, TRectMake (const TRect< U > &rect)
 
template<typename U >
constexpr static std::optional< TRectMakePointBounds (const U &value)
 
template<typename PointIter >
constexpr static std::optional< TRectMakePointBounds (const PointIter first, const PointIter last)
 
constexpr static TRect MakeMaximum ()
 
constexpr static TRect Union (const TRect &a, const std::optional< TRect > b)
 
constexpr static TRect Union (const std::optional< TRect > a, const TRect &b)
 
constexpr static std::optional< TRectUnion (const std::optional< TRect > a, const std::optional< TRect > b)
 
constexpr static std::optional< TRectIntersection (const TRect &a, const std::optional< TRect > b)
 
constexpr static std::optional< TRectIntersection (const std::optional< TRect > a, const TRect &b)
 
constexpr static std::optional< TRectIntersection (const std::optional< TRect > a, const std::optional< TRect > b)
 

Detailed Description

template<class T>
struct impeller::TRect< T >

Templated struct for holding an axis-aligned rectangle.

Rectangles are defined as 4 axis-aligned edges that might contain space. They can be viewed as 2 X coordinates that define the left and right edges and 2 Y coordinates that define the top and bottom edges; or they can be viewed as an origin and horizontal and vertical dimensions (width and height).

When the left and right edges are equal or reversed (right <= left) or the top and bottom edges are equal or reversed (bottom <= top), the rectangle is considered empty. Considering the rectangle in XYWH form, the width and/or the height would be negative or zero. Such reversed/empty rectangles contain no space and act as such in the methods that operate on them (Intersection, Union, IntersectsWithRect, Contains, Cutout, etc.)

Rectangles cannot be modified by any method and a new value can only be stored into an existing rect using assignment. This keeps the API clean compared to implementations that might have similar methods that produce the answer in place, or construct a new object with the answer, or place the result in an indicated result object.

Methods that might fail to produce an answer will use |std::optional| to indicate that success or failure (see |Intersection| and |CutOut|). For convenience, |Intersection| and |Union| both have overloaded variants that take |std::optional| arguments and treat them as if the argument was an empty rect to allow chaining multiple such methods and only needing to check the optional condition of the final result. The primary methods also provide |...OrEmpty| overloaded variants that translate an empty optional answer into a simple empty rectangle of the same type.

Rounding instance methods are not provided as the return value might be wanted as another floating point rectangle or sometimes as an integer rectangle. Instead a |RoundOut| factory, defined only for floating point input rectangles, is provided to provide control over the result type.

NaN and Infinity values

Constructing an LTRB rectangle using Infinity values should work as expected with either 0 or +Infinity returned as dimensions depending on which side the Infinity values are on and the sign.

Constructing an XYWH rectangle using Infinity values will usually not work if the math requires the object to compute a right or bottom edge from ([xy] -Infinity + [wh] +Infinity). Other combinations might work.

The special factory |MakeMaximum| is provided to construct a rectangle of the indicated coordinate type that covers all finite coordinates. It does not use infinity values, but rather the largest finite values to avoid math that might produce a NaN value from various getters.

Any rectangle that is constructed with, or computed to have a NaN value will be considered the same as any empty rectangle.

Empty Rectangle canonical results summary:

Union will ignore any empty rects and return the other rect Intersection will return nullopt if either rect is empty IntersectsWithRect will return false if either rect is empty Cutout will return the source rect if the argument is empty Cutout will return nullopt if the source rectangle is empty Contains(Point) will return false if the source rectangle is empty Contains(Rect) will return false if the source rectangle is empty Contains(Rect) will otherwise return true if the argument is empty Specifically, EmptyRect.Contains(EmptyRect) returns false


Special notes on problems using the XYWH form of specifying rectangles:

It is possible to have integer rectangles whose dimensions exceed the maximum number that their coordinates can represent since (MAX_INT - MIN_INT) overflows the representable positive numbers. Floating point rectangles technically have a similar issue in that overflow can occur, but it will be automatically converted into either an infinity, or a finite-overflow value and still be representable, just with little to no precision.

Secondly, specifying a rectangle using XYWH leads to cases where the math for (x+w) and/or (y+h) are also beyond the maximum representable coordinates. For N-bit integer rectangles declared as XYWH, the maximum right coordinate will require N+1 signed bits which cannot be stored in storage that uses N-bit integers.

Saturated math is used when constructing a rectangle from XYWH values and when returning the dimensions of the rectangle. Constructing an integer rectangle from values such that xy + wh is beyond the range of the integer type will place the right or bottom edges at the maximum value for the integer type. Similarly, constructing an integer rectangle such that the distance from the left to the right (or top to bottom) is greater than the range of the integer type will simply return the maximum integer value as the dimension. Floating point rectangles are naturally saturated by the rules of IEEE arithmetic.

Definition at line 122 of file rect.h.

Constructor & Destructor Documentation

◆ TRect()

Member Function Documentation

◆ Area()

template<class T >
constexpr T impeller::TRect< T >::Area ( ) const
inlineconstexpr

Get the area of the rectangle, equivalent to |GetSize().Area()|.

Definition at line 380 of file rect.h.

380  {
381  // TODO(141710): Use saturated math to avoid overflow.
382  return IsEmpty() ? 0 : (right_ - left_) * (bottom_ - top_);
383  }
constexpr bool IsEmpty() const
Returns true if either of the width or height are 0, negative, or NaN.
Definition: rect.h:301

References impeller::TRect< T >::IsEmpty().

Referenced by impeller::BlitPass::AddCopy(), and impeller::BlitCopyBufferToTextureCommandGLES::Encode().

◆ Contains() [1/2]

template<class T >
constexpr bool impeller::TRect< T >::Contains ( const TPoint< Type > &  p) const
inlineconstexpr

Returns true iff the provided point |p| is inside the half-open interior of this rectangle.

For purposes of containment, a rectangle contains points along the top and left edges but not points along the right and bottom edges so that a point is only ever considered inside one of two abutting rectangles.

Definition at line 235 of file rect.h.

235  {
236  return !this->IsEmpty() && //
237  p.x >= left_ && //
238  p.y >= top_ && //
239  p.x < right_ && //
240  p.y < bottom_;
241  }

References impeller::TRect< T >::IsEmpty(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by impeller::RoundRect::Contains(), impeller::RoundSuperellipse::Contains(), impeller::FillPathSourceGeometry::CoversArea(), impeller::FillRectGeometry::CoversArea(), impeller::RoundRectGeometry::CoversArea(), impeller::FillRoundRectGeometry::CoversArea(), impeller::RoundSuperellipseGeometry::CoversArea(), impeller::TiledTextureContents::RenderToSnapshot(), and impeller::testing::TEST().

◆ Contains() [2/2]

template<class T >
constexpr bool impeller::TRect< T >::Contains ( const TRect< T > &  o) const
inlineconstexpr

Returns true iff this rectangle is not empty and it also contains every point considered inside the provided rectangle |o| (as determined by |Contains(TPoint)|).

This is similar to a definition where the result is true iff the union of the two rectangles is equal to this rectangle, ignoring precision issues with performing those operations and assuming that empty rectangles are never equal.

An empty rectangle can contain no other rectangle.

An empty rectangle is, however, contained within any other non-empy rectangle as the set of points it contains is an empty set and so there are no points to fail the containment criteria.

Definition at line 277 of file rect.h.

277  {
278  return !this->IsEmpty() && //
279  (o.IsEmpty() || (o.left_ >= left_ && //
280  o.top_ >= top_ && //
281  o.right_ <= right_ && //
282  o.bottom_ <= bottom_));
283  }

References impeller::TRect< T >::IsEmpty().

◆ ContainsInclusive()

template<class T >
constexpr bool impeller::TRect< T >::ContainsInclusive ( const TPoint< Type > &  p) const
inlineconstexpr

Returns true iff the provided point |p| is inside the closed-range interior of this rectangle.

Unlike the regular |Contains(TPoint)| method, this method considers all points along the boundary of the rectangle to be contained within the rectangle - useful for testing if vertices that define a filled shape would carry the interior of that shape outside the bounds of the rectangle. Since both geometries are defining half-open spaces, their defining geometry needs to consider their boundaries to be equivalent with respect to interior and exterior.

Definition at line 254 of file rect.h.

254  {
255  return !this->IsEmpty() && //
256  p.x >= left_ && //
257  p.y >= top_ && //
258  p.x <= right_ && //
259  p.y <= bottom_;
260  }

References impeller::TRect< T >::IsEmpty(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by impeller::testing::TEST().

◆ Cutout()

template<class T >
constexpr std::optional<TRect<T> > impeller::TRect< T >::Cutout ( const TRect< T > &  o) const
inlineconstexpr

Returns the new boundary rectangle that would result from this rectangle being cut out by the specified rectangle.

Definition at line 561 of file rect.h.

561  {
562  if (IsEmpty()) {
563  // This test isn't just a short-circuit, it also prevents the concise
564  // math below from returning the wrong answer on empty rects.
565  // Once we know that this rectangle is not empty, the math below can
566  // only succeed in computing a value if o is also non-empty and non-nan.
567  // Otherwise, the method returns *this by default.
568  return std::nullopt;
569  }
570 
571  const auto& [a_left, a_top, a_right, a_bottom] = GetLTRB(); // Source rect.
572  const auto& [b_left, b_top, b_right, b_bottom] = o.GetLTRB(); // Cutout.
573  if (b_left <= a_left && b_right >= a_right) {
574  if (b_top <= a_top && b_bottom >= a_bottom) {
575  // Full cutout.
576  return std::nullopt;
577  }
578  if (b_top <= a_top && b_bottom > a_top) {
579  // Cuts off the top.
580  return TRect::MakeLTRB(a_left, b_bottom, a_right, a_bottom);
581  }
582  if (b_bottom >= a_bottom && b_top < a_bottom) {
583  // Cuts off the bottom.
584  return TRect::MakeLTRB(a_left, a_top, a_right, b_top);
585  }
586  }
587  if (b_top <= a_top && b_bottom >= a_bottom) {
588  if (b_left <= a_left && b_right > a_left) {
589  // Cuts off the left.
590  return TRect::MakeLTRB(b_right, a_top, a_right, a_bottom);
591  }
592  if (b_right >= a_right && b_left < a_right) {
593  // Cuts off the right.
594  return TRect::MakeLTRB(a_left, a_top, b_left, a_bottom);
595  }
596  }
597 
598  return *this;
599  }
constexpr std::array< T, 4 > GetLTRB() const
Definition: rect.h:391
constexpr static TRect MakeLTRB(Type left, Type top, Type right, Type bottom)
Definition: rect.h:129

References impeller::TRect< T >::GetLTRB(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::MakeLTRB().

Referenced by impeller::TRect< T >::CutoutOrEmpty(), and impeller::testing::TEST().

◆ CutoutOrEmpty()

template<class T >
constexpr TRect impeller::TRect< T >::CutoutOrEmpty ( const TRect< T > &  o) const
inlineconstexpr

Definition at line 601 of file rect.h.

601  {
602  return Cutout(o).value_or(TRect());
603  }
constexpr TRect()
Definition: rect.h:127
constexpr std::optional< TRect< T > > Cutout(const TRect &o) const
Returns the new boundary rectangle that would result from this rectangle being cut out by the specifi...
Definition: rect.h:561

References impeller::TRect< T >::Cutout(), and impeller::TRect< T >::TRect().

Referenced by impeller::testing::TEST().

◆ Expand() [1/5]

template<class T >
constexpr TRect<T> impeller::TRect< T >::Expand ( amount) const
inlineconstexpr

Returns a rectangle with expanded edges in all directions. Negative expansion results in shrinking.

Definition at line 636 of file rect.h.

636  {
637  return {
638  saturated::Sub(left_, amount), //
639  saturated::Sub(top_, amount), //
640  saturated::Add(right_, amount), //
641  saturated::Add(bottom_, amount), //
642  };
643  }

◆ Expand() [2/5]

template<class T >
constexpr TRect<T> impeller::TRect< T >::Expand ( horizontal_amount,
vertical_amount 
) const
inlineconstexpr

Returns a rectangle with expanded edges in all directions. Negative expansion results in shrinking.

Definition at line 647 of file rect.h.

648  {
649  return {
650  saturated::Sub(left_, horizontal_amount), //
651  saturated::Sub(top_, vertical_amount), //
652  saturated::Add(right_, horizontal_amount), //
653  saturated::Add(bottom_, vertical_amount), //
654  };
655  }

◆ Expand() [3/5]

template<class T >
constexpr TRect<T> impeller::TRect< T >::Expand ( left,
top,
right,
bottom 
) const
inlineconstexpr

◆ Expand() [4/5]

template<class T >
constexpr TRect<T> impeller::TRect< T >::Expand ( TPoint< T >  amount) const
inlineconstexpr

Returns a rectangle with expanded edges in all directions. Negative expansion results in shrinking.

Definition at line 659 of file rect.h.

659  {
660  return Expand(amount.x, amount.y);
661  }
constexpr TRect< T > Expand(T left, T top, T right, T bottom) const
Returns a rectangle with expanded edges. Negative expansion results in shrinking.
Definition: rect.h:622

References impeller::TRect< T >::Expand(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ Expand() [5/5]

template<class T >
constexpr TRect<T> impeller::TRect< T >::Expand ( TSize< T >  amount) const
inlineconstexpr

Returns a rectangle with expanded edges in all directions. Negative expansion results in shrinking.

Definition at line 665 of file rect.h.

665  {
666  return Expand(amount.width, amount.height);
667  }

References impeller::TRect< T >::Expand(), impeller::TSize< T >::height, and impeller::TSize< T >::width.

◆ GetBottom()

◆ GetCenter()

template<class T >
constexpr Point impeller::TRect< T >::GetCenter ( ) const
inlineconstexpr

◆ GetHeight()

◆ GetLeft()

◆ GetLeftBottom()

template<class T >
constexpr TPoint<T> impeller::TRect< T >::GetLeftBottom ( ) const
inlineconstexpr

◆ GetLeftTop()

◆ GetLTRB()

template<class T >
constexpr std::array<T, 4> impeller::TRect< T >::GetLTRB ( ) const
inlineconstexpr

Definition at line 391 of file rect.h.

391  {
392  return {left_, top_, right_, bottom_};
393  }

Referenced by impeller::TRect< T >::Cutout().

◆ GetNormalizingTransform()

template<class T >
constexpr Matrix impeller::TRect< T >::GetNormalizingTransform ( ) const
inlineconstexpr

Constructs a Matrix that will map all points in the coordinate space of the rectangle into a new normalized coordinate space where the upper left corner of the rectangle maps to (0, 0) and the lower right corner of the rectangle maps to (1, 1).

Empty and non-finite rectangles will return a zero-scaling transform that maps all points to (0, 0).

Definition at line 495 of file rect.h.

495  {
496  if (!IsEmpty()) {
497  Scalar sx = 1.0 / GetWidth();
498  Scalar sy = 1.0 / GetHeight();
499  Scalar tx = left_ * -sx;
500  Scalar ty = top_ * -sy;
501 
502  // Exclude NaN and infinities and either scale underflowing to zero
503  if (sx != 0.0 && sy != 0.0 && 0.0 * sx * sy * tx * ty == 0.0) {
504  // clang-format off
505  return Matrix( sx, 0.0f, 0.0f, 0.0f,
506  0.0f, sy, 0.0f, 0.0f,
507  0.0f, 0.0f, 1.0f, 0.0f,
508  tx, ty, 0.0f, 1.0f);
509  // clang-format on
510  }
511  }
512 
513  // Map all coordinates to the origin.
514  return Matrix::MakeScale({0.0f, 0.0f, 1.0f});
515  }
float Scalar
Definition: scalar.h:19
static constexpr Matrix MakeScale(const Vector3 &s)
Definition: matrix.h:104
constexpr Type GetHeight() const
Returns the height of the rectangle, equivalent to |GetSize().height|.
Definition: rect.h:351
constexpr Type GetWidth() const
Returns the width of the rectangle, equivalent to |GetSize().width|.
Definition: rect.h:345

References impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::IsEmpty(), and impeller::Matrix::MakeScale().

Referenced by impeller::DlVerticesGeometry::GetPositionUVColorBuffer(), and impeller::TiledTextureContents::Render().

◆ GetOrigin()

template<class T >
constexpr TPoint<Type> impeller::TRect< T >::GetOrigin ( ) const
inlineconstexpr

Returns the upper left corner of the rectangle as specified by the left/top or x/y values when it was constructed.

Definition at line 324 of file rect.h.

324  {
325  return {left_, top_};
326  }

Referenced by impeller::AdvancedBlend(), impeller::DirectionalMorphologyFilterContents::GetFilterCoverage(), impeller::PipelineBlend(), impeller::SolidRRectLikeBlurContents::Render(), impeller::Canvas::Restore(), and impeller::testing::TEST().

◆ GetPoints()

template<class T >
constexpr std::array<TPoint<T>, 4> impeller::TRect< T >::GetPoints ( ) const
inlineconstexpr

Get the points that represent the 4 corners of this rectangle in a Z order that is compatible with triangle strips or a set of all zero points if the rectangle is empty. The order is: Top left, top right, bottom left, bottom right.

Definition at line 418 of file rect.h.

418  {
419  if (IsEmpty()) {
420  return {};
421  }
422  return {
423  TPoint{left_, top_},
424  TPoint{right_, top_},
425  TPoint{left_, bottom_},
426  TPoint{right_, bottom_},
427  };
428  }

References impeller::TRect< T >::IsEmpty().

Referenced by impeller::DrawImageRectAtlasGeometry::CreateBlendVertexBuffer(), impeller::DrawImageRectAtlasGeometry::CreateSimpleVertexBuffer(), impeller::FillRectGeometry::GetPositionBuffer(), impeller::TRect< T >::GetTransformedPoints(), impeller::ClipContents::Render(), and impeller::testing::TEST().

◆ GetPositive()

template<class T >
constexpr TRect impeller::TRect< T >::GetPositive ( ) const
inlineconstexpr

Get a version of this rectangle that has a non-negative size.

Definition at line 402 of file rect.h.

402  {
403  if (!IsEmpty()) {
404  return *this;
405  }
406  return {
407  std::min(left_, right_),
408  std::min(top_, bottom_),
409  std::max(left_, right_),
410  std::max(top_, bottom_),
411  };
412  }

References impeller::TRect< T >::IsEmpty().

Referenced by impeller::DashedLinePathSource::GetBounds(), impeller::RoundRect::MakeRectRadii(), impeller::RoundSuperellipse::MakeRectRadii(), impeller::SolidRRectLikeBlurContents::Render(), impeller::RoundingRadii::Scaled(), and impeller::testing::TEST().

◆ GetRight()

◆ GetRightBottom()

◆ GetRightTop()

◆ GetSize()

◆ GetTop()

◆ GetTransformedPoints()

template<class T >
constexpr std::array<TPoint<T>, 4> impeller::TRect< T >::GetTransformedPoints ( const Matrix transform) const
inlineconstexpr

Definition at line 430 of file rect.h.

431  {
432  auto points = GetPoints();
433  for (size_t i = 0; i < points.size(); i++) {
434  points[i] = transform * points[i];
435  }
436  return points;
437  }
constexpr std::array< TPoint< T >, 4 > GetPoints() const
Get the points that represent the 4 corners of this rectangle in a Z order that is compatible with tr...
Definition: rect.h:418
std::vector< Point > points

References impeller::TRect< T >::GetPoints(), points, and transform.

Referenced by impeller::GaussianBlurFilterContents::CalculateUVs(), impeller::Snapshot::GetCoverageUVs(), impeller::testing::TEST(), and impeller::TRect< T >::TransformBounds().

◆ GetWidth()

◆ GetX()

◆ GetXYWH()

template<class T >
constexpr std::array<T, 4> impeller::TRect< T >::GetXYWH ( ) const
inlineconstexpr

Get the x, y coordinates of the origin and the width and height of the rectangle in an array.

Definition at line 397 of file rect.h.

397  {
398  return {left_, top_, GetWidth(), GetHeight()};
399  }

References impeller::TRect< T >::GetHeight(), and impeller::TRect< T >::GetWidth().

Referenced by impeller::testing::TEST().

◆ GetY()

◆ Intersection() [1/4]

template<class T >
constexpr static std::optional<TRect> impeller::TRect< T >::Intersection ( const std::optional< TRect< T > >  a,
const std::optional< TRect< T > >  b 
)
inlinestaticconstexpr

Definition at line 734 of file rect.h.

736  {
737  return a.has_value() ? Intersection(a.value(), b) : b;
738  }
constexpr std::optional< TRect > Intersection(const TRect &o) const
Definition: rect.h:532

References impeller::saturated::b, and impeller::TRect< T >::Intersection().

◆ Intersection() [2/4]

template<class T >
constexpr static std::optional<TRect> impeller::TRect< T >::Intersection ( const std::optional< TRect< T > >  a,
const TRect< T > &  b 
)
inlinestaticconstexpr

Definition at line 728 of file rect.h.

730  {
731  return a.has_value() ? a->Intersection(b) : b;
732  }

References impeller::saturated::b.

◆ Intersection() [3/4]

template<class T >
constexpr static std::optional<TRect> impeller::TRect< T >::Intersection ( const TRect< T > &  a,
const std::optional< TRect< T > >  b 
)
inlinestaticconstexpr

Definition at line 722 of file rect.h.

724  {
725  return b.has_value() ? a.Intersection(b.value()) : a;
726  }

References impeller::saturated::b, and impeller::TRect< T >::Intersection().

◆ Intersection() [4/4]

template<class T >
constexpr std::optional<TRect> impeller::TRect< T >::Intersection ( const TRect< T > &  o) const
inlineconstexpr

Definition at line 532 of file rect.h.

533  {
534  if (IntersectsWithRect(o)) {
535  return TRect{
536  std::max(left_, o.left_),
537  std::max(top_, o.top_),
538  std::min(right_, o.right_),
539  std::min(bottom_, o.bottom_),
540  };
541  } else {
542  return std::nullopt;
543  }
544  }
constexpr bool IntersectsWithRect(const TRect &o) const
Definition: rect.h:550

References impeller::TRect< T >::IntersectsWithRect().

Referenced by impeller::AdvancedBlend(), impeller::ComputeSaveLayerCoverage(), impeller::Canvas::DrawImageRect(), impeller::Canvas::GetLocalCoverageLimit(), impeller::TRect< T >::Intersection(), impeller::TRect< T >::IntersectionOrEmpty(), impeller::PipelineBlend(), and impeller::testing::TEST().

◆ IntersectionOrEmpty()

template<class T >
constexpr TRect impeller::TRect< T >::IntersectionOrEmpty ( const TRect< T > &  o) const
inlineconstexpr

Definition at line 546 of file rect.h.

546  {
547  return Intersection(o).value_or(TRect());
548  }

References impeller::TRect< T >::Intersection(), and impeller::TRect< T >::TRect().

Referenced by impeller::testing::TEST().

◆ IntersectsWithRect()

template<class T >
constexpr bool impeller::TRect< T >::IntersectsWithRect ( const TRect< T > &  o) const
inlineconstexpr

Definition at line 550 of file rect.h.

550  {
551  return !IsEmpty() && //
552  !o.IsEmpty() && //
553  left_ < o.right_ && //
554  top_ < o.bottom_ && //
555  right_ > o.left_ && //
556  bottom_ > o.top_;
557  }

References impeller::TRect< T >::IsEmpty().

Referenced by impeller::TRect< T >::Intersection(), and impeller::testing::TEST().

◆ IsEmpty()

◆ IsFinite()

template<class T >
impeller::TRect< T >::IsFinite ( ) const
inline

Returns true if all of the fields of this floating point rectangle are finite.

Note that the results of |GetWidth()| and |GetHeight()| may still be infinite due to overflow even if the fields themselves are finite.

Definition at line 292 of file rect.h.

292  {
293  return std::isfinite(left_) && //
294  std::isfinite(top_) && //
295  std::isfinite(right_) && //
296  std::isfinite(bottom_);
297  }

Referenced by impeller::Arc::Arc(), impeller::RoundRect::IsFinite(), impeller::RoundSuperellipse::IsFinite(), impeller::RoundRect::MakeRectRadii(), impeller::RoundSuperellipse::MakeRectRadii(), and impeller::testing::TEST().

◆ IsMaximum()

template<class T >
constexpr bool impeller::TRect< T >::IsMaximum ( ) const
inlineconstexpr

Definition at line 318 of file rect.h.

318  {
319  return *this == MakeMaximum();
320  }
constexpr static TRect MakeMaximum()
Definition: rect.h:188

References impeller::TRect< T >::MakeMaximum().

Referenced by impeller::ComputeSaveLayerCoverage(), and impeller::FirstPassDispatcher::drawDisplayList().

◆ IsSquare()

template<class T >
constexpr bool impeller::TRect< T >::IsSquare ( ) const
inlineconstexpr

Returns true if width and height are equal and neither is NaN.

Definition at line 308 of file rect.h.

308  {
309  // empty rectangles can technically be "square", but would be
310  // misleading to most callers. Using |IsEmpty| also prevents
311  // "non-empty and non-overflowing" computations from happening
312  // to be equal to "empty and overflowing" results.
313  // (Consider LTRB(10, 15, MAX-2, MIN+2) which is empty, but both
314  // w/h subtractions equal "5").
315  return !IsEmpty() && (right_ - left_) == (bottom_ - top_);
316  }

References impeller::TRect< T >::IsEmpty().

Referenced by impeller::Canvas::DrawArc(), impeller::Canvas::DrawOval(), impeller::Tessellator::FilledEllipse(), and impeller::Arc::IsPerfectCircle().

◆ Make()

template<class T >
template<class U , class FT = T>
constexpr static std::enable_if_t<std::is_floating_point_v<FT>, TRect> impeller::TRect< T >::Make ( const TRect< U > &  rect)
inlinestaticconstexpr

Construct a floating point rect |Rect| from another Rect of a potentially different storage type (eg. |IRect|).

Definition at line 157 of file rect.h.

158  {
159  return MakeLTRB(
160  static_cast<FT>(rect.GetLeft()), static_cast<FT>(rect.GetTop()),
161  static_cast<FT>(rect.GetRight()), static_cast<FT>(rect.GetBottom()));
162  }

References impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetLeft(), impeller::TRect< T >::GetRight(), impeller::TRect< T >::GetTop(), and impeller::TRect< T >::MakeLTRB().

◆ MakeLTRB()

template<class T >
constexpr static TRect impeller::TRect< T >::MakeLTRB ( Type  left,
Type  top,
Type  right,
Type  bottom 
)
inlinestaticconstexpr

◆ MakeMaximum()

template<class T >
constexpr static TRect impeller::TRect< T >::MakeMaximum ( )
inlinestaticconstexpr

Definition at line 188 of file rect.h.

188  {
189  return TRect::MakeLTRB(std::numeric_limits<Type>::lowest(),
190  std::numeric_limits<Type>::lowest(),
191  std::numeric_limits<Type>::max(),
192  std::numeric_limits<Type>::max());
193  }

References impeller::TRect< T >::MakeLTRB().

Referenced by impeller::TRect< T >::IsMaximum(), and impeller::testing::TEST().

◆ MakeOriginSize()

template<class T >
constexpr static TRect impeller::TRect< T >::MakeOriginSize ( const TPoint< Type > &  origin,
const TSize< Type > &  size 
)
inlinestaticconstexpr

Definition at line 144 of file rect.h.

145  {
146  return MakeXYWH(origin.x, origin.y, size.width, size.height);
147  }
constexpr static TRect MakeXYWH(Type x, Type y, Type width, Type height)
Definition: rect.h:136

References impeller::TSize< T >::height, impeller::TRect< T >::MakeXYWH(), impeller::TSize< T >::width, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by impeller::testing::TEST().

◆ MakePointBounds() [1/2]

template<class T >
template<typename PointIter >
constexpr static std::optional<TRect> impeller::TRect< T >::MakePointBounds ( const PointIter  first,
const PointIter  last 
)
inlinestaticconstexpr

Definition at line 170 of file rect.h.

171  {
172  if (first == last) {
173  return std::nullopt;
174  }
175  auto left = first->x;
176  auto top = first->y;
177  auto right = first->x;
178  auto bottom = first->y;
179  for (auto it = first + 1; it < last; ++it) {
180  left = std::min(left, it->x);
181  top = std::min(top, it->y);
182  right = std::max(right, it->x);
183  bottom = std::max(bottom, it->y);
184  }
185  return TRect::MakeLTRB(left, top, right, bottom);
186  }

References impeller::TRect< T >::MakeLTRB().

◆ MakePointBounds() [2/2]

template<class T >
template<typename U >
constexpr static std::optional<TRect> impeller::TRect< T >::MakePointBounds ( const U &  value)
inlinestaticconstexpr

Definition at line 165 of file rect.h.

165  {
166  return MakePointBounds(value.begin(), value.end());
167  }
int32_t value
constexpr static std::optional< TRect > MakePointBounds(const U &value)
Definition: rect.h:165

References value.

Referenced by impeller::TRect< T >::TransformAndClipBounds(), and impeller::TRect< T >::TransformBounds().

◆ MakeSize()

template<class T >
template<class U >
constexpr static TRect impeller::TRect< T >::MakeSize ( const TSize< U > &  size)
inlinestaticconstexpr

◆ MakeWH()

template<class T >
constexpr static TRect impeller::TRect< T >::MakeWH ( Type  width,
Type  height 
)
inlinestaticconstexpr

Definition at line 140 of file rect.h.

140  {
141  return TRect(0, 0, width, height);
142  }

References impeller::TRect< T >::TRect().

Referenced by impeller::testing::TEST().

◆ MakeXYWH()

template<class T >
constexpr static TRect impeller::TRect< T >::MakeXYWH ( Type  x,
Type  y,
Type  width,
Type  height 
)
inlinestaticconstexpr

Definition at line 136 of file rect.h.

136  {
137  return TRect(x, y, saturated::Add(x, width), saturated::Add(y, height));
138  }
int32_t x

References impeller::TRect< T >::TRect(), and x.

Referenced by impeller::BulkUpdateAtlasBitmap(), impeller::TRect< T >::MakeOriginSize(), impeller::testing::TEST(), and impeller::UpdateAtlasBitmap().

◆ operator!=()

template<class T >
constexpr bool impeller::TRect< T >::operator!= ( const TRect< T > &  r) const
inlineconstexpr

Definition at line 202 of file rect.h.

202  {
203  return !(*this == r);
204  }

◆ operator==()

template<class T >
constexpr bool impeller::TRect< T >::operator== ( const TRect< T > &  r) const
inlineconstexpr

Definition at line 195 of file rect.h.

195  {
196  return left_ == r.left_ && //
197  top_ == r.top_ && //
198  right_ == r.right_ && //
199  bottom_ == r.bottom_;
200  }

◆ Project()

template<class T >
constexpr TRect<T> impeller::TRect< T >::Project ( TRect< T >  source) const
inlineconstexpr

Returns a new rectangle that represents the projection of the source rectangle onto this rectangle. In other words, the source rectangle is redefined in terms of the coordinate space of this rectangle.

Definition at line 673 of file rect.h.

673  {
674  if (IsEmpty()) {
675  return {};
676  }
677  return source.Shift(-left_, -top_)
678  .Scale(1.0 / static_cast<Scalar>(GetWidth()),
679  1.0 / static_cast<Scalar>(GetHeight()));
680  }

References impeller::TRect< T >::GetHeight(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::IsEmpty(), and impeller::TRect< T >::Shift().

Referenced by impeller::DrawImageRectAtlasGeometry::CreateBlendVertexBuffer(), impeller::DrawImageRectAtlasGeometry::CreateSimpleVertexBuffer(), and impeller::TextureContents::Render().

◆ Round()

template<class T >
impeller::TRect< T >::Round ( const TRect< U > &  r)
inline

Definition at line 699 of file rect.h.

699  {
700  return TRect::MakeLTRB(saturated::Cast<U, Type>(round(r.GetLeft())),
701  saturated::Cast<U, Type>(round(r.GetTop())),
702  saturated::Cast<U, Type>(round(r.GetRight())),
703  saturated::Cast<U, Type>(round(r.GetBottom())));
704  }

References impeller::TRect< T >::MakeLTRB().

Referenced by impeller::testing::TEST().

◆ RoundIn()

template<class T >
impeller::TRect< T >::RoundIn ( const TRect< U > &  r)
inline

Definition at line 691 of file rect.h.

691  {
692  return TRect::MakeLTRB(saturated::Cast<U, Type>(ceil(r.GetLeft())),
693  saturated::Cast<U, Type>(ceil(r.GetTop())),
694  saturated::Cast<U, Type>(floor(r.GetRight())),
695  saturated::Cast<U, Type>(floor(r.GetBottom())));
696  }

References impeller::TRect< T >::MakeLTRB().

◆ RoundOut()

template<class T >
impeller::TRect< T >::RoundOut ( const TRect< U > &  r)
inline

Definition at line 683 of file rect.h.

683  {
684  return TRect::MakeLTRB(saturated::Cast<U, Type>(floor(r.GetLeft())),
685  saturated::Cast<U, Type>(floor(r.GetTop())),
686  saturated::Cast<U, Type>(ceil(r.GetRight())),
687  saturated::Cast<U, Type>(ceil(r.GetBottom())));
688  }

References impeller::TRect< T >::MakeLTRB().

Referenced by ImGui_ImplImpeller_RenderDrawData(), impeller::RenderToTarget(), impeller::Canvas::SaveLayer(), and impeller::testing::TEST().

◆ Scale() [1/4]

template<class T >
constexpr TRect impeller::TRect< T >::Scale ( TPoint< T >  scale) const
inlineconstexpr

Definition at line 220 of file rect.h.

220  {
221  return Scale(scale.x, scale.y);
222  }
constexpr TRect Scale(Type scale) const
Definition: rect.h:206

References impeller::TRect< T >::Scale(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ Scale() [2/4]

template<class T >
constexpr TRect impeller::TRect< T >::Scale ( TSize< T >  scale) const
inlineconstexpr

Definition at line 224 of file rect.h.

224  {
225  return Scale(scale.width, scale.height);
226  }

References impeller::TSize< T >::height, impeller::TRect< T >::Scale(), and impeller::TSize< T >::width.

◆ Scale() [3/4]

template<class T >
constexpr TRect impeller::TRect< T >::Scale ( Type  scale) const
inlineconstexpr

Definition at line 206 of file rect.h.

206  {
207  return TRect(left_ * scale, //
208  top_ * scale, //
209  right_ * scale, //
210  bottom_ * scale);
211  }

References impeller::TRect< T >::TRect().

Referenced by impeller::TextContents::ComputeVertexData(), ImGui_ImplImpeller_RenderDrawData(), impeller::TRect< T >::Scale(), and impeller::testing::TEST().

◆ Scale() [4/4]

template<class T >
constexpr TRect impeller::TRect< T >::Scale ( Type  scale_x,
Type  scale_y 
) const
inlineconstexpr

Definition at line 213 of file rect.h.

213  {
214  return TRect(left_ * scale_x, //
215  top_ * scale_y, //
216  right_ * scale_x, //
217  bottom_ * scale_y);
218  }

References impeller::TRect< T >::TRect().

◆ Shift() [1/2]

template<class T >
constexpr TRect<T> impeller::TRect< T >::Shift ( dx,
dy 
) const
inlineconstexpr

Returns a new rectangle translated by the given offset.

Definition at line 606 of file rect.h.

606  {
607  return {
608  saturated::Add(left_, dx), //
609  saturated::Add(top_, dy), //
610  saturated::Add(right_, dx), //
611  saturated::Add(bottom_, dy), //
612  };
613  }

Referenced by impeller::Canvas::DrawImage(), impeller::TRect< T >::Project(), impeller::testing::RectMakeCenterSize(), impeller::RoundRect::Shift(), impeller::RoundSuperellipse::Shift(), impeller::TRect< T >::Shift(), and impeller::testing::TEST_P().

◆ Shift() [2/2]

template<class T >
constexpr TRect<T> impeller::TRect< T >::Shift ( TPoint< T >  offset) const
inlineconstexpr

Returns a new rectangle translated by the given offset.

Definition at line 616 of file rect.h.

616  {
617  return Shift(offset.x, offset.y);
618  }
constexpr TRect< T > Shift(T dx, T dy) const
Returns a new rectangle translated by the given offset.
Definition: rect.h:606

References impeller::TRect< T >::Shift(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ TransformAndClipBounds()

template<class T >
constexpr TRect impeller::TRect< T >::TransformAndClipBounds ( const Matrix transform) const
inlineconstexpr

Creates a new bounding box that contains this transformed rectangle, clipped against the near clipping plane if necessary.

Definition at line 442 of file rect.h.

443  {
444  if (!transform.HasPerspective2D()) {
445  return TransformBounds(transform);
446  }
447 
448  if (IsEmpty()) {
449  return {};
450  }
451 
452  auto ul = transform.TransformHomogenous({left_, top_});
453  auto ur = transform.TransformHomogenous({right_, top_});
454  auto ll = transform.TransformHomogenous({left_, bottom_});
455  auto lr = transform.TransformHomogenous({right_, bottom_});
456 
457  // It can probably be proven that we only ever have 5 points at most
458  // which happens when only 1 corner is clipped and we get 2 points
459  // in return for it as we interpolate against its neighbors.
460  Point points[8];
461  int index = 0;
462 
463  // Process (clip and interpolate) each point against its 2 neighbors:
464  // left, pt, right
465  index = ClipAndInsert(points, index, ll, ul, ur);
466  index = ClipAndInsert(points, index, ul, ur, lr);
467  index = ClipAndInsert(points, index, ur, lr, ll);
468  index = ClipAndInsert(points, index, lr, ll, ul);
469 
470  auto bounds = TRect::MakePointBounds(points, points + index);
471  return bounds.value_or(TRect{});
472  }
TPoint< Scalar > Point
Definition: point.h:327
constexpr TRect TransformBounds(const Matrix &transform) const
Creates a new bounding box that contains this transformed rectangle.
Definition: rect.h:476

References impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::MakePointBounds(), points, transform, and impeller::TRect< T >::TransformBounds().

Referenced by impeller::testing::TEST().

◆ TransformBounds()

template<class T >
constexpr TRect impeller::TRect< T >::TransformBounds ( const Matrix transform) const
inlineconstexpr

Creates a new bounding box that contains this transformed rectangle.

Definition at line 476 of file rect.h.

476  {
477  if (IsEmpty()) {
478  return {};
479  }
481  auto bounds = TRect::MakePointBounds(points.begin(), points.end());
482  if (bounds.has_value()) {
483  return bounds.value();
484  }
485  FML_UNREACHABLE();
486  }
constexpr std::array< TPoint< T >, 4 > GetTransformedPoints(const Matrix &transform) const
Definition: rect.h:430

References impeller::TRect< T >::GetTransformedPoints(), impeller::TRect< T >::IsEmpty(), impeller::TRect< T >::MakePointBounds(), points, and transform.

Referenced by impeller::ComputeSaveLayerCoverage(), impeller::FillRectGeometry::CoversArea(), impeller::RoundRectGeometry::CoversArea(), impeller::FillRoundRectGeometry::CoversArea(), impeller::RoundSuperellipseGeometry::CoversArea(), impeller::DlDispatcherBase::drawDisplayList(), impeller::Canvas::DrawImageRect(), impeller::Snapshot::GetCoverage(), impeller::AtlasContents::GetCoverage(), impeller::ColorFilterAtlasContents::GetCoverage(), impeller::SolidRRectLikeBlurContents::GetCoverage(), impeller::TextureContents::GetCoverage(), impeller::DlVerticesGeometry::GetCoverage(), impeller::PointFieldGeometry::GetCoverage(), impeller::FillRectGeometry::GetCoverage(), impeller::StrokeRectGeometry::GetCoverage(), impeller::MatrixFilterContents::GetFilterCoverage(), impeller::LocalMatrixFilterContents::GetFilterSourceCoverage(), impeller::StrokeSegmentsGeometry::GetStrokeCoverage(), impeller::testing::TEST(), and impeller::TRect< T >::TransformAndClipBounds().

◆ Union() [1/4]

template<class T >
constexpr static std::optional<TRect> impeller::TRect< T >::Union ( const std::optional< TRect< T > >  a,
const std::optional< TRect< T > >  b 
)
inlinestaticconstexpr

Definition at line 716 of file rect.h.

718  {
719  return a.has_value() ? Union(a.value(), b) : b;
720  }
constexpr TRect Union(const TRect &o) const
Definition: rect.h:517

References impeller::saturated::b, and impeller::TRect< T >::Union().

◆ Union() [2/4]

template<class T >
constexpr static TRect impeller::TRect< T >::Union ( const std::optional< TRect< T > >  a,
const TRect< T > &  b 
)
inlinestaticconstexpr

Definition at line 711 of file rect.h.

712  {
713  return a.has_value() ? a->Union(b) : b;
714  }

References impeller::saturated::b, and impeller::TRect< T >::Union().

◆ Union() [3/4]

template<class T >
constexpr static TRect impeller::TRect< T >::Union ( const TRect< T > &  a,
const std::optional< TRect< T > >  b 
)
inlinestaticconstexpr

Definition at line 706 of file rect.h.

707  {
708  return b.has_value() ? a.Union(b.value()) : a;
709  }

References impeller::saturated::b, and impeller::TRect< T >::Union().

◆ Union() [4/4]

template<class T >
constexpr TRect impeller::TRect< T >::Union ( const TRect< T > &  o) const
inlineconstexpr

Definition at line 517 of file rect.h.

517  {
518  if (IsEmpty()) {
519  return o;
520  }
521  if (o.IsEmpty()) {
522  return *this;
523  }
524  return {
525  std::min(left_, o.left_),
526  std::min(top_, o.top_),
527  std::max(right_, o.right_),
528  std::max(bottom_, o.bottom_),
529  };
530  }

References impeller::TRect< T >::IsEmpty().

Referenced by impeller::testing::TEST(), and impeller::TRect< T >::Union().


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