impeller::PathBuilder Class Reference

#include <path_builder.h>

Classes
struct	RoundingRadii

Public Member Functions
	PathBuilder ()
	~PathBuilder ()
Path	CopyPath (FillType fill=FillType::kNonZero) const
Path	TakePath (FillType fill=FillType::kNonZero)
const Path &	GetCurrentPath () const
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 &	SmoothQuadraticCurveTo (Point point, bool relative=false)
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 &	SmoothCubicCurveTo (Point controlPoint2, Point point, bool relative=false)
PathBuilder &	AddRect (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 (Point p1, Point cp, Point p2)
	Move to point p1, then insert a quadradic curve from p1 to p2 with the control point cp. More...
PathBuilder &	AddCubicCurve (Point p1, Point cp1, Point cp2, 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 &	AddRoundedRect (Rect rect, RoundingRadii radii)
PathBuilder &	AddRoundedRect (Rect rect, Scalar radius)
PathBuilder &	AddPath (const Path &path)

Static Public Attributes
constexpr static const Scalar	kArcApproximationMagic = 0.551915024494f

Detailed Description

Definition at line 13 of file path_builder.h.

Constructor & Destructor Documentation

PathBuilder()

impeller::PathBuilder::PathBuilder ( )

default

~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 325 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 radius = {oval_bounds.size.width * 0.5f,
                        oval_bounds.size.height * 0.5f};
  const Point center = {oval_bounds.origin.x + radius.x,
                        oval_bounds.origin.y + radius.y};
 
  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;
 
    prototype_.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::TSize< T >::height, impeller::k2Pi, kArcApproximationMagic, impeller::kPiOver2, LineTo(), MoveTo(), impeller::TRect< T >::origin, impeller::Radians::radians, impeller::TRect< T >::size, impeller::TSize< T >::width, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by impeller::DlDispatcher::drawArc().

AddCircle()

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

Definition at line 198 of file path_builder.cc.

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

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

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

AddCubicCurve()

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

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

Definition at line 172 of file path_builder.cc.

                                                  {
  MoveTo(p1);
  prototype_.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 433 of file path_builder.cc.

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

References MoveTo().

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

AddOval()

PathBuilder & impeller::PathBuilder::AddOval

(

const Rect &

rect

)

Definition at line 385 of file path_builder.cc.

                                                       {
  const Point r = {container.size.width * 0.5f, container.size.height * 0.5f};
  const Point c = {container.origin.x + r.x, container.origin.y + r.y};
  const Point m = {kArcApproximationMagic * r.x, kArcApproximationMagic * r.y};
 
  MoveTo({c.x, c.y - r.y});
 
  //----------------------------------------------------------------------------
  // Top right arc.
  //
  prototype_.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.
  //
  prototype_.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.
  //
  prototype_.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.
  //
  prototype_.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::TSize< T >::height, kArcApproximationMagic, MoveTo(), impeller::TRect< T >::origin, impeller::TRect< T >::size, impeller::TSize< T >::width, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by AddCircle(), impeller::DlDispatcher::drawOval(), and impeller::testing::TEST().

AddPath()

PathBuilder & impeller::PathBuilder::AddPath

(

const Path &

path

)

Definition at line 443 of file path_builder.cc.

                                                  {
  auto linear = [&](size_t index, const LinearPathComponent& l) {
    prototype_.AddLinearComponent(l.p1, l.p2);
  };
  auto quadratic = [&](size_t index, const QuadraticPathComponent& q) {
    prototype_.AddQuadraticComponent(q.p1, q.cp, q.p2);
  };
  auto cubic = [&](size_t index, const CubicPathComponent& c) {
    prototype_.AddCubicComponent(c.p1, c.cp1, c.cp2, c.p2);
  };
  auto move = [&](size_t index, const ContourComponent& m) {
    prototype_.AddContourComponent(m.destination);
  };
  path.EnumerateComponents(linear, quadratic, cubic, move);
  return *this;
}

References impeller::Path::EnumerateComponents().

Referenced by impeller::DlDispatcher::drawDRRect().

AddQuadraticCurve()

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

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

Definition at line 166 of file path_builder.cc.

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

References MoveTo().

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

AddRect()

PathBuilder & impeller::PathBuilder::AddRect

(

Rect

rect

)

Definition at line 181 of file path_builder.cc.

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

References Close(), impeller::TSize< T >::height, MoveTo(), impeller::TRect< T >::origin, impeller::TRect< T >::size, and impeller::TSize< T >::width.

Referenced by AddRoundedRect(), impeller::testing::CreatePassWithRectPath(), impeller::Canvas::DrawRect(), impeller::testing::TEST(), and impeller::testing::TEST_P().

AddRoundedRect() [1/2]

PathBuilder & impeller::PathBuilder::AddRoundedRect	(	Rect	rect,
		RoundingRadii	radii
	)

Definition at line 207 of file path_builder.cc.

                                                                       {
  if (radii.AreAllZero()) {
    return AddRect(rect);
  }
 
  current_ = rect.origin + Point{radii.top_left.x, 0.0};
 
  MoveTo({rect.origin.x + radii.top_left.x, rect.origin.y});
 
  //----------------------------------------------------------------------------
  // Top line.
  //
  prototype_.AddLinearComponent(
      {rect.origin.x + radii.top_left.x, rect.origin.y},
      {rect.origin.x + rect.size.width - radii.top_right.x, rect.origin.y});
 
  //----------------------------------------------------------------------------
  // Top right arc.
  //
  AddRoundedRectTopRight(rect, radii);
 
  //----------------------------------------------------------------------------
  // Right line.
  //
  prototype_.AddLinearComponent(
      {rect.origin.x + rect.size.width, rect.origin.y + radii.top_right.y},
      {rect.origin.x + rect.size.width,
       rect.origin.y + rect.size.height - radii.bottom_right.y});
 
  //----------------------------------------------------------------------------
  // Bottom right arc.
  //
  AddRoundedRectBottomRight(rect, radii);
 
  //----------------------------------------------------------------------------
  // Bottom line.
  //
  prototype_.AddLinearComponent(
      {rect.origin.x + rect.size.width - radii.bottom_right.x,
       rect.origin.y + rect.size.height},
      {rect.origin.x + radii.bottom_left.x, rect.origin.y + rect.size.height});
 
  //----------------------------------------------------------------------------
  // Bottom left arc.
  //
  AddRoundedRectBottomLeft(rect, radii);
 
  //----------------------------------------------------------------------------
  // Left line.
  //
  prototype_.AddLinearComponent(
      {rect.origin.x, rect.origin.y + rect.size.height - radii.bottom_left.y},
      {rect.origin.x, rect.origin.y + radii.top_left.y});
 
  //----------------------------------------------------------------------------
  // Top left arc.
  //
  AddRoundedRectTopLeft(rect, radii);
 
  Close();
 
  return *this;
}

References AddRect(), impeller::PathBuilder::RoundingRadii::AreAllZero(), impeller::PathBuilder::RoundingRadii::bottom_left, impeller::PathBuilder::RoundingRadii::bottom_right, Close(), impeller::TSize< T >::height, MoveTo(), impeller::TRect< T >::origin, impeller::TRect< T >::size, impeller::PathBuilder::RoundingRadii::top_left, impeller::PathBuilder::RoundingRadii::top_right, impeller::TSize< T >::width, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by AddRoundedRect(), impeller::Canvas::ClipRRect(), impeller::Canvas::DrawRRect(), impeller::testing::TEST(), impeller::testing::TEST_P(), and impeller::skia_conversions::ToPath().

AddRoundedRect() [2/2]

PathBuilder & impeller::PathBuilder::AddRoundedRect	(	Rect	rect,
		Scalar	radius
	)

Definition at line 202 of file path_builder.cc.

                                                                 {
  return radius <= 0.0 ? AddRect(rect)
                       : AddRoundedRect(rect, {radius, radius, radius, radius});
}

References AddRect(), and AddRoundedRect().

Close()

PathBuilder & impeller::PathBuilder::Close

(

)

Definition at line 39 of file path_builder.cc.

                                {
  LineTo(subpath_start_);
  prototype_.SetContourClosed(true);
  prototype_.AddContourComponent(current_);
  return *this;
}

References LineTo().

Referenced by AddArc(), AddOval(), AddRect(), AddRoundedRect(), impeller::Close(), impeller::testing::TEST(), impeller::testing::TEST_P(), and impeller::skia_conversions::ToPath().

CopyPath()

Path impeller::PathBuilder::CopyPath

(

FillType

fill = FillType::kNonZero

)

const

Definition at line 15 of file path_builder.cc.

                                              {
  auto path = prototype_;
  path.SetFillType(fill);
  return path;
}

Referenced by impeller::Tessellate().

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 116 of file path_builder.cc.

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

Referenced by impeller::CubicTo(), SmoothCubicCurveTo(), and impeller::skia_conversions::ToPath().

GetCurrentPath()

const Path & impeller::PathBuilder::GetCurrentPath

(

)

const

Definition at line 439 of file path_builder.cc.

                                              {
  return prototype_;
}

HorizontalLineTo()

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

Definition at line 53 of file path_builder.cc.

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

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

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 46 of file path_builder.cc.

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

Referenced by AddArc(), Close(), impeller::LineTo(), impeller::testing::TEST(), impeller::testing::TEST_P(), and impeller::skia_conversions::ToPath().

MoveTo()

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

Definition at line 32 of file path_builder.cc.

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

Referenced by AddArc(), AddCubicCurve(), AddLine(), AddOval(), AddQuadraticCurve(), AddRect(), AddRoundedRect(), impeller::MoveTo(), impeller::testing::TEST(), impeller::testing::TEST_P(), and impeller::skia_conversions::ToPath().

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 69 of file path_builder.cc.

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

Referenced by SmoothQuadraticCurveTo(), and impeller::skia_conversions::ToPath().

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 465 of file path_builder.cc.

                                               {
  prototype_.SetBounds(bounds);
  did_compute_bounds_ = true;
  return *this;
}

Referenced by impeller::skia_conversions::ToPath().

SetConvexity()

PathBuilder & impeller::PathBuilder::SetConvexity

(

Convexity

value

)

Definition at line 111 of file path_builder.cc.

                                                      {
  convexity_ = value;
  return *this;
}

Referenced by impeller::Canvas::ClipRRect(), impeller::Canvas::DrawCircle(), impeller::DlDispatcher::drawLine(), impeller::DlDispatcher::drawOval(), impeller::Canvas::DrawRRect(), impeller::testing::TEST_P(), and impeller::skia_conversions::ToPath().

Shift()

PathBuilder & impeller::PathBuilder::Shift

(

Point

offset

)

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

Definition at line 460 of file path_builder.cc.

                                            {
  prototype_.Shift(offset);
  return *this;
}

Referenced by impeller::testing::TEST(), and impeller::skia_conversions::ToPath().

SmoothCubicCurveTo()

PathBuilder & impeller::PathBuilder::SmoothCubicCurveTo	(	Point	controlPoint2,
		Point	point,
		bool	relative = false
	)

Definition at line 151 of file path_builder.cc.

                                                            {
  auto controlPoint1 = ReflectedCubicControlPoint1();
  controlPoint2 = relative ? current_ + controlPoint2 : controlPoint2;
  auto endpoint = relative ? current_ + point : point;
 
  CubicCurveTo(endpoint,       // endpoint
               controlPoint1,  // control point 1
               controlPoint2,  // control point 2
               false           // relative since all points are already absolute
  );
  return *this;
}

References CubicCurveTo().

SmoothQuadraticCurveTo()

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

Definition at line 101 of file path_builder.cc.

                                                                           {
  point = relative ? current_ + point : point;
  /*
   *  The reflected control point is absolute and we made the endpoint absolute
   *  too. So there the last argument is always false (i.e, not relative).
   */
  QuadraticCurveTo(point, ReflectedQuadraticControlPoint1(), false);
  return *this;
}

References QuadraticCurveTo().

TakePath()

Path impeller::PathBuilder::TakePath

(

FillType

fill = FillType::kNonZero

)

Definition at line 21 of file path_builder.cc.

                                        {
  auto path = prototype_;
  path.SetFillType(fill);
  path.SetConvexity(convexity_);
  if (!did_compute_bounds_) {
    path.ComputeBounds();
  }
  did_compute_bounds_ = false;
  return path;
}

Referenced by impeller::Canvas::ClipRRect(), impeller::DlDispatcher::drawArc(), impeller::Canvas::DrawCircle(), impeller::DlDispatcher::drawDRRect(), impeller::DlDispatcher::drawLine(), impeller::DlDispatcher::drawOval(), impeller::DlDispatcher::drawPoints(), impeller::Canvas::DrawRRect(), impeller::testing::TEST(), impeller::testing::TEST_P(), and impeller::skia_conversions::ToPath().

VerticalLineTo()

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

Definition at line 61 of file path_builder.cc.

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

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

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 22 of file path_builder.h.

Referenced by AddArc(), and AddOval().

---

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

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