#include <path_component.h>

Public Types
using	PointProc = std::function< void(const Point &point)>

Public Member Functions
	QuadraticPathComponent ()

	QuadraticPathComponent (Point ap1, Point acp, Point ap2)

Point	Solve (Scalar time) const

Point	SolveDerivative (Scalar time) const

void	AppendPolylinePoints (Scalar scale_factor, std::vector< Point > &points) const

void	ToLinearPathComponents (Scalar scale_factor, const PointProc &proc) const

void	ToLinearPathComponents (Scalar scale, VertexWriter &writer) const

std::vector< Point >	Extrema () const

bool	operator== (const QuadraticPathComponent &other) const

std::optional< Vector2 >	GetStartDirection () const

std::optional< Vector2 >	GetEndDirection () const

Public Attributes
Point	p1

Point	cp

Point	p2

Detailed Description

Definition at line 63 of file path_component.h.

Member Typedef Documentation

◆ PointProc

using impeller::QuadraticPathComponent::PointProc = std::function<void(const Point& point)>

Definition at line 83 of file path_component.h.

Constructor & Destructor Documentation

◆ QuadraticPathComponent() [1/2]

impeller::QuadraticPathComponent::QuadraticPathComponent ( )

inline

Definition at line 71 of file path_component.h.

71 {}

◆ QuadraticPathComponent() [2/2]

impeller::QuadraticPathComponent::QuadraticPathComponent	(	Point	ap1,
		Point	acp,
		Point	ap2
	)

inline

Definition at line 73 of file path_component.h.

74 : p1(ap1), cp(acp), p2(ap2) {}

Member Function Documentation

◆ AppendPolylinePoints()

void impeller::QuadraticPathComponent::AppendPolylinePoints	(	Scalar	scale_factor,
		std::vector< Point > &	points
	)		const

Definition at line 171 of file path_component.cc.

                                     {
   ToLinearPathComponents(scale_factor, [&points](const Point& point) {
     points.emplace_back(point);
   });
 }

References ToLinearPathComponents().

◆ Extrema()

std::vector< Point > impeller::QuadraticPathComponent::Extrema ( ) const

Definition at line 190 of file path_component.cc.

                                                        {
   CubicPathComponent elevated(*this);
   return elevated.Extrema();
 }

References impeller::CubicPathComponent::Extrema().

◆ GetEndDirection()

std::optional< Vector2 > impeller::QuadraticPathComponent::GetEndDirection ( ) const

Definition at line 205 of file path_component.cc.

                                                                    {
   if (p2 != cp) {
     return (p2 - cp).Normalize();
   }
   if (p2 != p1) {
     return (p2 - p1).Normalize();
   }
   return std::nullopt;
 }

References cp, p1, and p2.

Referenced by impeller::PathComponentEndDirectionVisitor::operator()().

◆ GetStartDirection()

std::optional< Vector2 > impeller::QuadraticPathComponent::GetStartDirection ( ) const

Definition at line 195 of file path_component.cc.

                                                                      {
   if (p1 != cp) {
     return (p1 - cp).Normalize();
   }
   if (p1 != p2) {
     return (p1 - p2).Normalize();
   }
   return std::nullopt;
 }

References cp, p1, and p2.

Referenced by impeller::PathComponentStartDirectionVisitor::operator()().

◆ operator==()

bool impeller::QuadraticPathComponent::operator== ( const QuadraticPathComponent & other ) const

inline

Definition at line 91 of file path_component.h.

                                                              {
     return p1 == other.p1 && cp == other.cp && p2 == other.p2;
   }

References cp, p1, and p2.

◆ Solve()

Point impeller::QuadraticPathComponent::Solve ( Scalar time ) const

Definition at line 147 of file path_component.cc.

                                                      {
   return {
       QuadraticSolve(time, p1.x, cp.x, p2.x),  // x
       QuadraticSolve(time, p1.y, cp.y, p2.y),  // y
   };
 }

References cp, p1, p2, impeller::QuadraticSolve(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

Referenced by ToLinearPathComponents().

◆ SolveDerivative()

Point impeller::QuadraticPathComponent::SolveDerivative ( Scalar time ) const

Definition at line 154 of file path_component.cc.

                                                                {
   return {
       QuadraticSolveDerivative(time, p1.x, cp.x, p2.x),  // x
       QuadraticSolveDerivative(time, p1.y, cp.y, p2.y),  // y
   };
 }

References cp, p1, p2, impeller::QuadraticSolveDerivative(), impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

◆ ToLinearPathComponents() [1/2]

void impeller::QuadraticPathComponent::ToLinearPathComponents	(	Scalar	scale,
		VertexWriter &	writer
	)		const

Definition at line 161 of file path_component.cc.

                                 {
   Scalar line_count = std::ceilf(ComputeQuadradicSubdivisions(scale, *this));
   for (size_t i = 1; i < line_count; i += 1) {
     writer.Write(Solve(i / line_count));
   }
   writer.Write(p2);
 }

References impeller::ComputeQuadradicSubdivisions(), p2, scale, Solve(), and impeller::VertexWriter::Write().

◆ ToLinearPathComponents() [2/2]

void impeller::QuadraticPathComponent::ToLinearPathComponents	(	Scalar	scale_factor,
		const PointProc &	proc
	)		const

Definition at line 179 of file path_component.cc.

                                  {
   Scalar line_count =
       std::ceilf(ComputeQuadradicSubdivisions(scale_factor, *this));
   for (size_t i = 1; i < line_count; i += 1) {
     proc(Solve(i / line_count));
   }
   proc(p2);
 }