#include <path_builder.h>

Public Member Functions
	PathBuilder ()

	~PathBuilder ()

Path	CopyPath (FillType fill=FillType::kNonZero)

Path	TakePath (FillType fill=FillType::kNonZero)

void	Reserve (size_t point_size, size_t verb_size)
	Reserve [point_size] points and [verb_size] verbs in the underlying path buffer. More...

PathBuilder &	SetConvexity (Convexity value)

PathBuilder &	MoveTo (Point point, bool relative=false)

PathBuilder &	Close ()

PathBuilder &	LineTo (Point point, bool relative=false)
	Insert a line from the current position to `point`. More...

PathBuilder &	HorizontalLineTo (Scalar x, bool relative=false)

PathBuilder &	VerticalLineTo (Scalar y, bool relative=false)

PathBuilder &	QuadraticCurveTo (Point controlPoint, Point point, bool relative=false)
	Insert a quadradic curve from the current position to `point` using the control point `controlPoint`. More...

PathBuilder &	ConicCurveTo (Point controlPoint, Point point, Scalar weight, bool relative=false)
	Insert a conic curve from the current position to `point` using the control point `controlPoint` and the weight `weight`. More...

PathBuilder &	CubicCurveTo (Point controlPoint1, Point controlPoint2, Point point, bool relative=false)
	Insert a cubic curve from the curren position to `point` using the control points `controlPoint1` and `controlPoint2`. More...

PathBuilder &	AddRect (const Rect &rect)

PathBuilder &	AddCircle (const Point &center, Scalar radius)

PathBuilder &	AddArc (const Rect &oval_bounds, Radians start, Radians sweep, bool use_center=false)

PathBuilder &	AddOval (const Rect &rect)

PathBuilder &	AddLine (const Point &p1, const Point &p2)
	Move to point `p1`, then insert a line from `p1` to `p2`. More...

PathBuilder &	AddQuadraticCurve (const Point &p1, const Point &cp, const Point &p2)
	Move to point `p1`, then insert a quadradic curve from `p1` to `p2` with the control point `cp`. More...

PathBuilder &	AddConicCurve (const Point &p1, const Point &cp, const Point &p2, Scalar weight)
	Move to point `p1`, then insert a conic curve from `p1` to `p2` with the control point `cp` and weight `weight`. More...

PathBuilder &	AddCubicCurve (const Point &p1, const Point &cp1, const Point &cp2, const Point &p2)
	Move to point `p1`, then insert a cubic curve from `p1` to `p2` with control points `cp1` and `cp2`. More...

PathBuilder &	Shift (Point offset)
	Transform the existing path segments and contours by the given `offset`. More...

PathBuilder &	SetBounds (Rect bounds)
	Set the bounding box that will be used by `Path.GetBoundingBox` in place of performing the computation. More...

PathBuilder &	AddRoundRect (RoundRect rect)

PathBuilder &	AddRoundSuperellipse (RoundSuperellipse rse)

PathBuilder &	AddPath (const Path &path)

Static Public Attributes
constexpr static const Scalar	kArcApproximationMagic = 0.551915024494f

Detailed Description

Definition at line 16 of file path_builder.h.

Constructor & Destructor Documentation

◆ PathBuilder()

impeller::PathBuilder::PathBuilder ( )

Definition at line 15 of file path_builder.cc.

                          {
   AddContourComponent({});
 }

◆ ~PathBuilder()

impeller::PathBuilder::~PathBuilder ( )

default

Member Function Documentation

◆ AddArc()

PathBuilder & impeller::PathBuilder::AddArc	(	const Rect &	oval_bounds,
		Radians	start,
		Radians	sweep,
		bool	use_center = `false`
	)

Definition at line 397 of file path_builder.cc.

                                                   {
   if (sweep.radians < 0) {
     start.radians += sweep.radians;
     sweep.radians *= -1;
   }
   sweep.radians = std::min(k2Pi, sweep.radians);
   start.radians = std::fmod(start.radians, k2Pi);
  
   const Point center = oval_bounds.GetCenter();
   const Point radius = center - oval_bounds.GetOrigin();
  
   Vector2 p1_unit(std::cos(start.radians), std::sin(start.radians));
  
   if (use_center) {
     MoveTo(center);
     LineTo(center + p1_unit * radius);
   } else {
     MoveTo(center + p1_unit * radius);
   }
  
   while (sweep.radians > 0) {
     Vector2 p2_unit;
     Scalar quadrant_angle;
     if (sweep.radians < kPiOver2) {
       quadrant_angle = sweep.radians;
       p2_unit = Vector2(std::cos(start.radians + quadrant_angle),
                         std::sin(start.radians + quadrant_angle));
     } else {
       quadrant_angle = kPiOver2;
       p2_unit = Vector2(-p1_unit.y, p1_unit.x);
     }
  
     Vector2 arc_cp_lengths =
         (quadrant_angle / kPiOver2) * kArcApproximationMagic * radius;
  
     Point p1 = center + p1_unit * radius;
     Point p2 = center + p2_unit * radius;
     Point cp1 = p1 + Vector2(-p1_unit.y, p1_unit.x) * arc_cp_lengths;
     Point cp2 = p2 + Vector2(p2_unit.y, -p2_unit.x) * arc_cp_lengths;
  
     AddCubicComponent(p1, cp1, cp2, p2);
     current_ = p2;
  
     start.radians += quadrant_angle;
     sweep.radians -= quadrant_angle;
     p1_unit = p2_unit;
   }
  
   if (use_center) {
     Close();
   }
  
   return *this;
 }

References Close(), impeller::TRect< T >::GetCenter(), impeller::TRect< T >::GetOrigin(), impeller::k2Pi, kArcApproximationMagic, impeller::kPiOver2, LineTo(), MoveTo(), impeller::Radians::radians, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by impeller::DlDispatcherBase::drawArc(), and impeller::testing::TEST().

◆ AddCircle()

PathBuilder & impeller::PathBuilder::AddCircle	(	const Point &	center,
		Scalar	radius
	)

Definition at line 171 of file path_builder.cc.

                                                             {
   return AddOval(Rect::MakeXYWH(c.x - r, c.y - r, 2.0f * r, 2.0f * r));
 }

References AddOval(), impeller::TRect< Scalar >::MakeXYWH(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

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

◆ AddConicCurve()

PathBuilder & impeller::PathBuilder::AddConicCurve	(	const Point &	p1,
		const Point &	cp,
		const Point &	p2,
		Scalar	weight
	)

Move to point p1, then insert a conic curve from p1 to p2 with the control point cp and weight weight.

Definition at line 135 of file path_builder.cc.

                                                        {
   MoveTo(p1);
   AddConicComponent(p1, cp, p2, weight);
   return *this;
 }

References MoveTo().

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

◆ AddCubicCurve()

PathBuilder & impeller::PathBuilder::AddCubicCurve	(	const Point &	p1,
		const Point &	cp1,
		const Point &	cp2,
		const Point &	p2
	)

Move to point p1, then insert a cubic curve from p1 to p2 with control points cp1 and cp2.

Definition at line 144 of file path_builder.cc.

                                                          {
   MoveTo(p1);
   AddCubicComponent(p1, cp1, cp2, p2);
   return *this;
 }

References MoveTo().

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

◆ AddLine()

PathBuilder & impeller::PathBuilder::AddLine	(	const Point &	p1,
		const Point &	p2
	)

Move to point p1, then insert a line from p1 to p2.

Definition at line 503 of file path_builder.cc.

                                                                   {
   MoveTo(p1);
   AddLinearComponent(p1, p2);
   return *this;
 }

References MoveTo().

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

◆ AddOval()

PathBuilder & impeller::PathBuilder::AddOval ( const Rect & rect )

Definition at line 455 of file path_builder.cc.

                                                        {
   const Point c = container.GetCenter();
   const Point r = c - container.GetOrigin();
   const Point m = r * kArcApproximationMagic;
  
   MoveTo({c.x, c.y - r.y});
  
   //----------------------------------------------------------------------------
   // Top right arc.
   //
   AddCubicComponent({c.x, c.y - r.y},        // p1
                     {c.x + m.x, c.y - r.y},  // cp1
                     {c.x + r.x, c.y - m.y},  // cp2
                     {c.x + r.x, c.y}         // p2
   );
  
   //----------------------------------------------------------------------------
   // Bottom right arc.
   //
   AddCubicComponent({c.x + r.x, c.y},        // p1
                     {c.x + r.x, c.y + m.y},  // cp1
                     {c.x + m.x, c.y + r.y},  // cp2
                     {c.x, c.y + r.y}         // p2
   );
  
   //----------------------------------------------------------------------------
   // Bottom left arc.
   //
   AddCubicComponent({c.x, c.y + r.y},        // p1
                     {c.x - m.x, c.y + r.y},  // cp1
                     {c.x - r.x, c.y + m.y},  // cp2
                     {c.x - r.x, c.y}         // p2
   );
  
   //----------------------------------------------------------------------------
   // Top left arc.
   //
   AddCubicComponent({c.x - r.x, c.y},        // p1
                     {c.x - r.x, c.y - m.y},  // cp1
                     {c.x - m.x, c.y - r.y},  // cp2
                     {c.x, c.y - r.y}         // p2
   );
  
   Close();
  
   return *this;
 }

References Close(), impeller::TRect< T >::GetCenter(), impeller::TRect< T >::GetOrigin(), kArcApproximationMagic, MoveTo(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by AddCircle(), AddRoundSuperellipse(), impeller::Canvas::DrawOval(), and impeller::testing::TEST().

◆ AddPath()

PathBuilder & impeller::PathBuilder::AddPath ( const Path & path )

Definition at line 509 of file path_builder.cc.

                                                   {
   auto& points = prototype_.points;
   auto& components = prototype_.components;
   size_t source_offset = points.size();
  
   points.insert(points.end(), path.data_->points.begin(),
                 path.data_->points.end());
   components.insert(components.end(), path.data_->components.begin(),
                     path.data_->components.end());
  
   for (auto component : path.data_->components) {
     if (component == Path::ComponentType::kContour) {
       current_contour_location_ = source_offset;
       contour_count_ += 1;
     }
     source_offset += Path::VerbToOffset(component);
   }
   return *this;
 }

References impeller::Path::kContour, and impeller::Path::VerbToOffset().

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

◆ AddQuadraticCurve()

PathBuilder & impeller::PathBuilder::AddQuadraticCurve	(	const Point &	p1,
		const Point &	cp,
		const Point &	p2
	)

Move to point p1, then insert a quadradic curve from p1 to p2 with the control point cp.

Definition at line 127 of file path_builder.cc.

                                                              {
   MoveTo(p1);
   AddQuadraticComponent(p1, cp, p2);
   return *this;
 }

References MoveTo().

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

◆ AddRect()

PathBuilder & impeller::PathBuilder::AddRect ( const Rect & rect )

Definition at line 153 of file path_builder.cc.

                                                   {
   auto origin = rect.GetOrigin();
   auto size = rect.GetSize();
  
   auto tl = origin;
   auto bl = origin + Point{0.0, size.height};
   auto br = origin + size;
   auto tr = origin + Point{size.width, 0.0};
  
   MoveTo(tl);
   LineTo(tr);
   LineTo(br);
   LineTo(bl);
   Close();
  
   return *this;
 }

References Close(), impeller::TRect< T >::GetOrigin(), impeller::TRect< T >::GetSize(), LineTo(), and MoveTo().

Referenced by AddRoundRect(), AddRoundSuperellipse(), impeller::Canvas::DrawRect(), impeller::testing::TEST(), and impeller::testing::TEST_P().

◆ AddRoundRect()

PathBuilder & impeller::PathBuilder::AddRoundRect ( RoundRect rect )

Definition at line 175 of file path_builder.cc.

                                                            {
   auto rect = round_rect.GetBounds();
   auto radii = round_rect.GetRadii();
   if (radii.AreAllCornersEmpty()) {
     return AddRect(rect);
   }
  
   auto rect_origin = rect.GetOrigin();
   auto rect_size = rect.GetSize();
  
   current_ = rect_origin + Point{radii.top_left.width, 0.0};
  
   MoveTo({rect_origin.x + radii.top_left.width, rect_origin.y});
  
   //----------------------------------------------------------------------------
   // Top line.
   //
   AddLinearComponentIfNeeded(
       {rect_origin.x + radii.top_left.width, rect_origin.y},
       {rect_origin.x + rect_size.width - radii.top_right.width, rect_origin.y});
  
   //----------------------------------------------------------------------------
   // Top right arc.
   //
   AddRoundedRectTopRight(rect, radii);
  
   //----------------------------------------------------------------------------
   // Right line.
   //
   AddLinearComponentIfNeeded(
       {rect_origin.x + rect_size.width, rect_origin.y + radii.top_right.height},
       {rect_origin.x + rect_size.width,
        rect_origin.y + rect_size.height - radii.bottom_right.height});
  
   //----------------------------------------------------------------------------
   // Bottom right arc.
   //
   AddRoundedRectBottomRight(rect, radii);
  
   //----------------------------------------------------------------------------
   // Bottom line.
   //
   AddLinearComponentIfNeeded(
       {rect_origin.x + rect_size.width - radii.bottom_right.width,
        rect_origin.y + rect_size.height},
       {rect_origin.x + radii.bottom_left.width,
        rect_origin.y + rect_size.height});
  
   //----------------------------------------------------------------------------
   // Bottom left arc.
   //
   AddRoundedRectBottomLeft(rect, radii);
  
   //----------------------------------------------------------------------------
   // Left line.
   //
   AddLinearComponentIfNeeded(
       {rect_origin.x,
        rect_origin.y + rect_size.height - radii.bottom_left.height},
       {rect_origin.x, rect_origin.y + radii.top_left.height});
  
   //----------------------------------------------------------------------------
   // Top left arc.
   //
   AddRoundedRectTopLeft(rect, radii);
  
   Close();
  
   return *this;
 }

References AddRect(), Close(), impeller::RoundRect::GetBounds(), impeller::RoundRect::GetRadii(), and MoveTo().

Referenced by impeller::DlDispatcherBase::clipRoundRect(), impeller::DlDispatcherBase::drawDiffRoundRect(), impeller::Canvas::DrawRoundRect(), and impeller::testing::TEST().

◆ AddRoundSuperellipse()

PathBuilder & impeller::PathBuilder::AddRoundSuperellipse ( RoundSuperellipse rse )

Definition at line 246 of file path_builder.cc.

                                                                     {
   if (rse.IsRect()) {
     AddRect(rse.GetBounds());
   } else if (rse.IsOval()) {
     AddOval(rse.GetBounds());
   } else {
     impeller::RoundSuperellipseParam::MakeBoundsRadii(rse.GetBounds(),
                                                       rse.GetRadii())
         .AddToPath(*this);
   }
   return *this;
 }

References AddOval(), AddRect(), impeller::RoundSuperellipseParam::AddToPath(), impeller::RoundSuperellipse::GetBounds(), impeller::RoundSuperellipse::GetRadii(), impeller::RoundSuperellipse::IsOval(), impeller::RoundSuperellipse::IsRect(), and impeller::RoundSuperellipseParam::MakeBoundsRadii().

Referenced by impeller::Canvas::DrawRoundSuperellipse(), impeller::testing::TEST(), and impeller::testing::TEST_P().

◆ Close()

PathBuilder & impeller::PathBuilder::Close ( )

Definition at line 54 of file path_builder.cc.

                                 {
   // If the subpath start is the same as the current position, this
   // is an empty contour and inserting a line segment will just
   // confuse the tessellator.
   if (subpath_start_ != current_) {
     LineTo(subpath_start_);
   }
   SetContourClosed(true);
   AddContourComponent(current_);
   return *this;
 }

References LineTo().

Referenced by AddArc(), AddOval(), AddRect(), AddRoundRect(), impeller::RoundSuperellipseParam::AddToPath(), impeller::Close(), impeller::testing::TEST(), and impeller::testing::TEST_P().

◆ ConicCurveTo()

PathBuilder & impeller::PathBuilder::ConicCurveTo	(	Point	controlPoint,
		Point	point,
		Scalar	weight,
		bool	relative = `false`
	)

Insert a conic curve from the current position to point using the control point controlPoint and the weight weight.

If relative is true the point and controlPoint are relative to current location.

Definition at line 99 of file path_builder.cc.

                                                       {
   point = relative ? current_ + point : point;
   controlPoint = relative ? current_ + controlPoint : controlPoint;
   AddConicComponent(current_, controlPoint, point, weight);
   current_ = point;
   return *this;
 }

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

◆ CopyPath()

Path impeller::PathBuilder::CopyPath ( FillType fill = FillType::kNonZero )

Definition at line 21 of file path_builder.cc.

                                         {
   prototype_.fill = fill;
   prototype_.single_contour =
       current_contour_location_ == 0u ||
       (contour_count_ == 2 &&
        prototype_.components.back() == Path::ComponentType::kContour);
   return Path(prototype_);
 }

References impeller::Path::kContour.

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

◆ CubicCurveTo()

PathBuilder & impeller::PathBuilder::CubicCurveTo	(	Point	controlPoint1,
		Point	controlPoint2,
		Point	point,
		bool	relative = `false`
	)

Insert a cubic curve from the curren position to point using the control points controlPoint1 and controlPoint2.

If relative is true the point, controlPoint1, and controlPoint2 are relative to current location.

Definition at line 115 of file path_builder.cc.

                                                       {
   controlPoint1 = relative ? current_ + controlPoint1 : controlPoint1;
   controlPoint2 = relative ? current_ + controlPoint2 : controlPoint2;
   point = relative ? current_ + point : point;
   AddCubicComponent(current_, controlPoint1, controlPoint2, point);
   current_ = point;
   return *this;
 }

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

◆ HorizontalLineTo()

PathBuilder & impeller::PathBuilder::HorizontalLineTo	(	Scalar	x,
		bool	relative = `false`
	)

Definition at line 73 of file path_builder.cc.

                                                                   {
   Point endpoint =
       relative ? Point{current_.x + x, current_.y} : Point{x, current_.y};
   AddLinearComponent(current_, endpoint);
   current_ = endpoint;
   return *this;
 }

References x, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

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

◆ LineTo()

PathBuilder & impeller::PathBuilder::LineTo	(	Point	point,
		bool	relative = `false`
	)

Insert a line from the current position to point.

If relative is true, then point is relative to the current location.

Definition at line 66 of file path_builder.cc.

                                                            {
   point = relative ? current_ + point : point;
   AddLinearComponent(current_, point);
   current_ = point;
   return *this;
 }

Referenced by AddArc(), AddRect(), impeller::RoundSuperellipseParam::AddToPath(), Close(), impeller::DlDispatcherBase::drawDashedLine(), impeller::LineTo(), impeller::testing::TEST(), and impeller::testing::TEST_P().

◆ MoveTo()

PathBuilder & impeller::PathBuilder::MoveTo	(	Point	point,
		bool	relative = `false`
	)

Definition at line 47 of file path_builder.cc.

                                                            {
   current_ = relative ? current_ + point : point;
   subpath_start_ = current_;
   AddContourComponent(current_);
   return *this;
 }

Referenced by AddArc(), AddConicCurve(), AddCubicCurve(), AddLine(), AddOval(), AddQuadraticCurve(), AddRect(), AddRoundRect(), impeller::RoundSuperellipseParam::AddToPath(), impeller::DlDispatcherBase::drawDashedLine(), impeller::MoveTo(), impeller::testing::TEST(), and impeller::testing::TEST_P().

◆ QuadraticCurveTo()

PathBuilder & impeller::PathBuilder::QuadraticCurveTo	(	Point	controlPoint,
		Point	point,
		bool	relative = `false`
	)

Insert a quadradic curve from the current position to point using the control point controlPoint.

If relative is true the point and controlPoint are relative to current location.

Definition at line 89 of file path_builder.cc.

                                                           {
   point = relative ? current_ + point : point;
   controlPoint = relative ? current_ + controlPoint : controlPoint;
   AddQuadraticComponent(current_, controlPoint, point);
   current_ = point;
   return *this;
 }

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

◆ Reserve()

void impeller::PathBuilder::Reserve	(	size_t	point_size,
		size_t	verb_size
	)

Reserve [point_size] points and [verb_size] verbs in the underlying path buffer.

Definition at line 42 of file path_builder.cc.

                                                              {
   prototype_.points.reserve(point_size);
   prototype_.components.reserve(verb_size);
 }

◆ SetBounds()

PathBuilder & impeller::PathBuilder::SetBounds ( Rect bounds )

Set the bounding box that will be used by Path.GetBoundingBox in place of performing the computation.

   When Impeller recieves Skia Path objects, many of these already
   have computed bounds. This method is used to avoid needlessly
   recomputing these bounds.

Definition at line 576 of file path_builder.cc.

                                                {
   prototype_.bounds = bounds;
   return *this;
 }

Referenced by impeller::DlDispatcherBase::drawDiffRoundRect(), impeller::Canvas::DrawRoundRect(), impeller::Canvas::DrawRoundSuperellipse(), impeller::testing::TEST(), and impeller::testing::TEST_P().

◆ SetConvexity()

PathBuilder & impeller::PathBuilder::SetConvexity ( Convexity value )

Definition at line 110 of file path_builder.cc.

                                                       {
   prototype_.convexity = value;
   return *this;
 }

References value.

Referenced by impeller::Canvas::DrawRoundRect(), impeller::Canvas::DrawRoundSuperellipse(), impeller::testing::TEST(), and impeller::testing::TEST_P().

◆ Shift()

PathBuilder & impeller::PathBuilder::Shift ( Point offset )

Transform the existing path segments and contours by the given offset.

Definition at line 529 of file path_builder.cc.

                                             {
   auto& points = prototype_.points;
   size_t storage_offset = 0u;
   for (const auto& component : prototype_.components) {
     switch (component) {
       case Path::ComponentType::kLinear: {
         auto* linear =
             reinterpret_cast<LinearPathComponent*>(&points[storage_offset]);
         linear->p1 += offset;
         linear->p2 += offset;
         break;
       }
       case Path::ComponentType::kQuadratic: {
         auto* quad =
             reinterpret_cast<QuadraticPathComponent*>(&points[storage_offset]);
         quad->p1 += offset;
         quad->p2 += offset;
         quad->cp += offset;
       } break;
       case Path::ComponentType::kConic: {
         auto* conic =
             reinterpret_cast<ConicPathComponent*>(&points[storage_offset]);
         conic->p1 += offset;
         conic->p2 += offset;
         conic->cp += offset;
       } break;
       case Path::ComponentType::kCubic: {
         auto* cubic =
             reinterpret_cast<CubicPathComponent*>(&points[storage_offset]);
         cubic->p1 += offset;
         cubic->p2 += offset;
         cubic->cp1 += offset;
         cubic->cp2 += offset;
       } break;
       case Path::ComponentType::kContour:
         auto* contour =
             reinterpret_cast<ContourComponent*>(&points[storage_offset]);
         contour->destination += offset;
         break;
     }
     storage_offset += Path::VerbToOffset(component);
   }
  
   prototype_.bounds.reset();
   return *this;
 }

References impeller::ContourComponent::destination, impeller::Path::kConic, impeller::Path::kContour, impeller::Path::kCubic, impeller::Path::kLinear, impeller::Path::kQuadratic, offset, impeller::LinearPathComponent::p1, impeller::QuadraticPathComponent::p1, impeller::ConicPathComponent::p1, impeller::CubicPathComponent::p1, and impeller::Path::VerbToOffset().

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

◆ TakePath()

Path impeller::PathBuilder::TakePath ( FillType fill = FillType::kNonZero )

Definition at line 30 of file path_builder.cc.

                                         {
   prototype_.fill = fill;
   UpdateBounds();
   prototype_.single_contour =
       current_contour_location_ == 0u ||
       (contour_count_ == 2 &&
        prototype_.components.back() == Path::ComponentType::kContour);
   current_contour_location_ = 0u;
   contour_count_ = 1;
   return Path(std::move(prototype_));
 }

References impeller::Path::kContour.

Referenced by impeller::DlDispatcherBase::drawArc(), impeller::DlDispatcherBase::drawDashedLine(), impeller::DlDispatcherBase::drawDiffRoundRect(), impeller::Canvas::DrawRoundRect(), impeller::Canvas::DrawRoundSuperellipse(), impeller::testing::TEST(), and impeller::testing::TEST_P().

◆ VerticalLineTo()

PathBuilder & impeller::PathBuilder::VerticalLineTo	(	Scalar	y,
		bool	relative = `false`
	)

Definition at line 81 of file path_builder.cc.

                                                                 {
   Point endpoint =
       relative ? Point{current_.x, current_.y + y} : Point{current_.x, y};
   AddLinearComponent(current_, endpoint);
   current_ = endpoint;
   return *this;
 }

References impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

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

Member Data Documentation

◆ kArcApproximationMagic

constexpr static const Scalar impeller::PathBuilder::kArcApproximationMagic = 0.551915024494f

staticconstexpr

Used for approximating quarter circle arcs with cubic curves. This is the control point distance which results in the smallest possible unit circle integration for a right angle arc. It can be used to approximate arcs less than 90 degrees to great effect by simply reducing it proportionally to the angle. However, accuracy rapidly diminishes if magnified for obtuse angle arcs, and so multiple cubic curves should be used when approximating arcs greater than 90 degrees.

Definition at line 25 of file path_builder.h.

Referenced by AddArc(), AddOval(), and flutter::testing::TEST_P().

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

impeller/geometry/path_builder.h
impeller/geometry/path_builder.cc

Public Member Functions

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PathBuilder()

◆ ~PathBuilder()

Member Function Documentation

◆ AddArc()

◆ AddCircle()

◆ AddConicCurve()

◆ AddCubicCurve()

◆ AddLine()

◆ AddOval()

◆ AddPath()

◆ AddQuadraticCurve()

◆ AddRect()

◆ AddRoundRect()

◆ AddRoundSuperellipse()

◆ Close()

◆ ConicCurveTo()

◆ CopyPath()

◆ CubicCurveTo()

◆ HorizontalLineTo()

◆ LineTo()

◆ MoveTo()

◆ QuadraticCurveTo()

◆ Reserve()

◆ SetBounds()

◆ SetConvexity()

◆ Shift()

◆ TakePath()

◆ VerticalLineTo()

Member Data Documentation

◆ kArcApproximationMagic