Paths are lightweight objects that describe a collection of linear, quadratic, or cubic segments. These segments may be broken up by move commands, which are effectively linear commands that pick up the pen rather than continuing to draw. More...

#include <path.h>

Classes
struct	Polyline

struct	PolylineContour

Public Types
enum	ComponentType { ComponentType::kLinear, ComponentType::kQuadratic, ComponentType::kCubic, ComponentType::kContour }

Public Member Functions
	Path ()

	~Path ()

size_t	GetComponentCount (std::optional< ComponentType > type={}) const

FillType	GetFillType () const

bool	IsConvex () const

bool	IsEmpty () const

bool	GetLinearComponentAtIndex (size_t index, LinearPathComponent &linear) const

bool	GetQuadraticComponentAtIndex (size_t index, QuadraticPathComponent &quadratic) const

bool	GetCubicComponentAtIndex (size_t index, CubicPathComponent &cubic) const

bool	GetContourComponentAtIndex (size_t index, ContourComponent &contour) const

Polyline	CreatePolyline (Scalar scale, Polyline::PointBufferPtr point_buffer=std::make_unique< std::vector< Point >>(), Polyline::ReclaimPointBufferCallback reclaim=nullptr) const

void	EndContour (size_t storage_offset, Polyline &polyline, size_t component_index, std::vector< PolylineContour::Component > &poly_components) const

std::optional< Rect >	GetBoundingBox () const

std::optional< Rect >	GetTransformedBoundingBox (const Matrix &transform) const

void	WritePolyline (Scalar scale, VertexWriter &writer) const

Static Public Member Functions
static constexpr size_t	VerbToOffset (Path::ComponentType verb)

Friends
class	PathBuilder

Detailed Description

Paths are lightweight objects that describe a collection of linear, quadratic, or cubic segments. These segments may be broken up by move commands, which are effectively linear commands that pick up the pen rather than continuing to draw.

All shapes supported by Impeller are paths either directly or via approximation (in the case of circles).

Paths are externally immutable once created, Creating paths must be done using a path builder.

Definition at line 52 of file path.h.

Member Enumeration Documentation

◆ ComponentType

enum impeller::Path::ComponentType

strong

Enumerator
kLinear
kQuadratic
kCubic
kContour

Definition at line 54 of file path.h.

                            {
     kLinear,
     kQuadratic,
     kCubic,
     kContour,
   };

Constructor & Destructor Documentation

◆ Path()

impeller::Path::Path ( )

Definition at line 15 of file path.cc.

15 : data_(new Data()) {}

◆ ~Path()

impeller::Path::~Path ( )

default

Member Function Documentation

◆ CreatePolyline()

Path::Polyline impeller::Path::CreatePolyline	(	Scalar	scale,
		Polyline::PointBufferPtr	point_buffer = `std::make_unique<std::vector<Point>>()`,
		Polyline::ReclaimPointBufferCallback	reclaim = `nullptr`
	)		const

Callers must provide the scale factor for how this path will be transformed.

It is suitable to use the max basis length of the matrix used to transform the path. If the provided scale is 0, curves will revert to straight lines.

Definition at line 289 of file path.cc.

                                                           {
   Polyline polyline(std::move(point_buffer), std::move(reclaim));
  
   auto& path_components = data_->components;
   auto& path_points = data_->points;
   std::optional<Vector2> start_direction;
   std::vector<PolylineContour::Component> poly_components;
   size_t storage_offset = 0u;
   size_t component_i = 0;
  
   for (; component_i < path_components.size(); component_i++) {
     auto path_component = path_components[component_i];
     switch (path_component) {
       case ComponentType::kLinear: {
         poly_components.push_back({
             .component_start_index = polyline.points->size() - 1,
             .is_curve = false,
         });
         auto* linear = reinterpret_cast<const LinearPathComponent*>(
             &path_points[storage_offset]);
         linear->AppendPolylinePoints(*polyline.points);
         if (!start_direction.has_value()) {
           start_direction = linear->GetStartDirection();
         }
         break;
       }
       case ComponentType::kQuadratic: {
         poly_components.push_back({
             .component_start_index = polyline.points->size() - 1,
             .is_curve = true,
         });
         auto* quad = reinterpret_cast<const QuadraticPathComponent*>(
             &path_points[storage_offset]);
         quad->AppendPolylinePoints(scale, *polyline.points);
         if (!start_direction.has_value()) {
           start_direction = quad->GetStartDirection();
         }
         break;
       }
       case ComponentType::kCubic: {
         poly_components.push_back({
             .component_start_index = polyline.points->size() - 1,
             .is_curve = true,
         });
         auto* cubic = reinterpret_cast<const CubicPathComponent*>(
             &path_points[storage_offset]);
         cubic->AppendPolylinePoints(scale, *polyline.points);
         if (!start_direction.has_value()) {
           start_direction = cubic->GetStartDirection();
         }
         break;
       }
       case ComponentType::kContour:
         if (component_i == path_components.size() - 1) {
           // If the last component is a contour, that means it's an empty
           // contour, so skip it.
           break;
         }
         if (!polyline.contours.empty()) {
           polyline.contours.back().start_direction =
               start_direction.value_or(Vector2(0, -1));
           start_direction = std::nullopt;
         }
         EndContour(storage_offset, polyline, component_i, poly_components);
  
         auto* contour = reinterpret_cast<const ContourComponent*>(
             &path_points[storage_offset]);
         polyline.contours.push_back(PolylineContour{
             .start_index = polyline.points->size(),  //
             .is_closed = contour->IsClosed(),        //
             .start_direction = Vector2(0, -1),       //
             .components = poly_components            //
         });
  
         polyline.points->push_back(contour->destination);
         break;
     }
     storage_offset += VerbToOffset(path_component);
   }
  
   // Subtract the last storage offset increment so that the storage lookup is
   // correct, including potentially an empty contour as well.
   if (component_i > 0 && path_components.back() == ComponentType::kContour) {
     storage_offset -= VerbToOffset(ComponentType::kContour);
     component_i--;
   }
  
   if (!polyline.contours.empty()) {
     polyline.contours.back().start_direction =
         start_direction.value_or(Vector2(0, -1));
   }
   EndContour(storage_offset, polyline, component_i, poly_components);
   return polyline;
 }

References impeller::LinearPathComponent::AppendPolylinePoints(), impeller::QuadraticPathComponent::AppendPolylinePoints(), impeller::CubicPathComponent::AppendPolylinePoints(), EndContour(), kContour, kCubic, kLinear, kQuadratic, polyline, scale, impeller::Path::PolylineContour::start_index, and VerbToOffset().

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

◆ EndContour()

void impeller::Path::EndContour	(	size_t	storage_offset,
		Polyline &	polyline,
		size_t	component_index,
		std::vector< PolylineContour::Component > &	poly_components
	)		const

Definition at line 225 of file path.cc.

                                                                 {
   auto& path_components = data_->components;
   auto& path_points = data_->points;
   // Whenever a contour has ended, extract the exact end direction from
   // the last component.
   if (polyline.contours.empty() || component_index == 0) {
     return;
   }
  
   auto& contour = polyline.contours.back();
   contour.end_direction = Vector2(0, 1);
   contour.components = poly_components;
   poly_components.clear();
  
   size_t previous_index = component_index - 1;
   storage_offset -= VerbToOffset(path_components[previous_index]);
  
   while (previous_index >= 0 && storage_offset >= 0) {
     const auto& path_component = path_components[previous_index];
     switch (path_component) {
       case ComponentType::kLinear: {
         auto* linear = reinterpret_cast<const LinearPathComponent*>(
             &path_points[storage_offset]);
         auto maybe_end = linear->GetEndDirection();
         if (maybe_end.has_value()) {
           contour.end_direction = maybe_end.value();
           return;
         }
         break;
       }
       case ComponentType::kQuadratic: {
         auto* quad = reinterpret_cast<const QuadraticPathComponent*>(
             &path_points[storage_offset]);
         auto maybe_end = quad->GetEndDirection();
         if (maybe_end.has_value()) {
           contour.end_direction = maybe_end.value();
           return;
         }
         break;
       }
       case ComponentType::kCubic: {
         auto* cubic = reinterpret_cast<const CubicPathComponent*>(
             &path_points[storage_offset]);
         auto maybe_end = cubic->GetEndDirection();
         if (maybe_end.has_value()) {
           contour.end_direction = maybe_end.value();
           return;
         }
         break;
       }
       case ComponentType::kContour: {
         // Hit previous contour, return.
         return;
       };
     }
     storage_offset -= VerbToOffset(path_component);
     previous_index--;
   }
 };

References impeller::LinearPathComponent::GetEndDirection(), impeller::QuadraticPathComponent::GetEndDirection(), impeller::CubicPathComponent::GetEndDirection(), kContour, kCubic, kLinear, kQuadratic, polyline, and VerbToOffset().

Referenced by CreatePolyline().

◆ GetBoundingBox()

std::optional< Rect > impeller::Path::GetBoundingBox ( ) const

Definition at line 387 of file path.cc.

                                              {
   return data_->bounds;
 }

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

◆ GetComponentCount()

size_t impeller::Path::GetComponentCount ( std::optional< ComponentType > type = {} ) const

Definition at line 33 of file path.cc.

                                                                     {
   if (!type.has_value()) {
     return data_->components.size();
   }
   auto type_value = type.value();
   size_t count = 0u;
   for (const auto& component : data_->components) {
     if (component == type_value) {
       count++;
     }
   }
   return count;
 }

References type.

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

◆ GetContourComponentAtIndex()

bool impeller::Path::GetContourComponentAtIndex	(	size_t	index,
		ContourComponent &	contour
	)		const

Definition at line 188 of file path.cc.

                                                                     {
   auto& components = data_->components;
   if (index >= components.size() ||
       components[index] != ComponentType::kContour) {
     return false;
   }
  
   size_t storage_offset = 0u;
   for (auto i = 0u; i < index; i++) {
     storage_offset += VerbToOffset(components[i]);
   }
   auto& points = data_->points;
  
   move = ContourComponent(points[storage_offset], points[storage_offset + 1]);
   return true;
 }

References kContour, and VerbToOffset().

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

◆ GetCubicComponentAtIndex()

bool impeller::Path::GetCubicComponentAtIndex	(	size_t	index,
		CubicPathComponent &	cubic
	)		const

Definition at line 168 of file path.cc.

                                                                      {
   auto& components = data_->components;
   if (index >= components.size() ||
       components[index] != ComponentType::kCubic) {
     return false;
   }
  
   size_t storage_offset = 0u;
   for (auto i = 0u; i < index; i++) {
     storage_offset += VerbToOffset(components[i]);
   }
   auto& points = data_->points;
  
   cubic = CubicPathComponent(points[storage_offset], points[storage_offset + 1],
                              points[storage_offset + 2],
                              points[storage_offset + 3]);
   return true;
 }

References kCubic, and VerbToOffset().

◆ GetFillType()

FillType impeller::Path::GetFillType ( ) const

Definition at line 47 of file path.cc.

                                  {
   return data_->fill;
 }

Referenced by impeller::TessellatorLibtess::Tessellate().

◆ GetLinearComponentAtIndex()

bool impeller::Path::GetLinearComponentAtIndex	(	size_t	index,
		LinearPathComponent &	linear
	)		const

Definition at line 129 of file path.cc.

                                                                         {
   auto& components = data_->components;
   if (index >= components.size() ||
       components[index] != ComponentType::kLinear) {
     return false;
   }
  
   size_t storage_offset = 0u;
   for (auto i = 0u; i < index; i++) {
     storage_offset += VerbToOffset(components[i]);
   }
   auto& points = data_->points;
   linear =
       LinearPathComponent(points[storage_offset], points[storage_offset + 1]);
   return true;
 }

References kLinear, and VerbToOffset().

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

◆ GetQuadraticComponentAtIndex()

bool impeller::Path::GetQuadraticComponentAtIndex	(	size_t	index,
		QuadraticPathComponent &	quadratic
	)		const

Definition at line 147 of file path.cc.

                                              {
   auto& components = data_->components;
   if (index >= components.size() ||
       components[index] != ComponentType::kQuadratic) {
     return false;
   }
  
   size_t storage_offset = 0u;
   for (auto i = 0u; i < index; i++) {
     storage_offset += VerbToOffset(components[i]);
   }
   auto& points = data_->points;
  
   quadratic =
       QuadraticPathComponent(points[storage_offset], points[storage_offset + 1],
                              points[storage_offset + 2]);
   return true;
 }

References kQuadratic, and VerbToOffset().

◆ GetTransformedBoundingBox()

std::optional< Rect > impeller::Path::GetTransformedBoundingBox ( const Matrix & transform ) const

Definition at line 391 of file path.cc.

                                    {
   auto bounds = GetBoundingBox();
   if (!bounds.has_value()) {
     return std::nullopt;
   }
   return bounds->TransformBounds(transform);
 }

References GetBoundingBox(), and transform.

◆ IsConvex()

bool impeller::Path::IsConvex ( ) const

Definition at line 51 of file path.cc.

                           {
   return data_->convexity == Convexity::kConvex;
 }

References impeller::kConvex.

◆ IsEmpty()

bool impeller::Path::IsEmpty ( ) const

Definition at line 55 of file path.cc.

                          {
   return data_->points.empty() ||
          (data_->components.size() == 1 &&
           data_->components[0] == ComponentType::kContour);
 }

References kContour.

◆ VerbToOffset()

static constexpr size_t impeller::Path::VerbToOffset ( Path::ComponentType verb )

inlinestaticconstexpr

Definition at line 61 of file path.h.

                                                                {
     switch (verb) {
       case Path::ComponentType::kLinear:
         return 2u;
       case Path::ComponentType::kQuadratic:
         return 3u;
       case Path::ComponentType::kCubic:
         return 4u;
       case Path::ComponentType::kContour:
         return 2u;
         break;
     }
     FML_UNREACHABLE();
   }

References kContour, kCubic, kLinear, and kQuadratic.

Referenced by impeller::PathBuilder::AddPath(), CreatePolyline(), EndContour(), GetContourComponentAtIndex(), GetCubicComponentAtIndex(), GetLinearComponentAtIndex(), GetQuadraticComponentAtIndex(), impeller::PathBuilder::Shift(), and WritePolyline().

◆ WritePolyline()

void impeller::Path::WritePolyline	(	Scalar	scale,
		VertexWriter &	writer
	)		const

Generate a polyline into the temporary storage held by the [writer].

It is suitable to use the max basis length of the matrix used to transform the path. If the provided scale is 0, curves will revert to straight lines.

Definition at line 61 of file path.cc.

                                                                  {
   auto& path_components = data_->components;
   auto& path_points = data_->points;
   bool started_contour = false;
   bool first_point = true;
  
   size_t storage_offset = 0u;
   for (size_t component_i = 0; component_i < path_components.size();
        component_i++) {
     const auto& path_component = path_components[component_i];
     switch (path_component) {
       case ComponentType::kLinear: {
         const LinearPathComponent* linear =
             reinterpret_cast<const LinearPathComponent*>(
                 &path_points[storage_offset]);
         if (first_point) {
           writer.Write(linear->p1);
           first_point = false;
         }
         writer.Write(linear->p2);
         break;
       }
       case ComponentType::kQuadratic: {
         const QuadraticPathComponent* quad =
             reinterpret_cast<const QuadraticPathComponent*>(
                 &path_points[storage_offset]);
         if (first_point) {
           writer.Write(quad->p1);
           first_point = false;
         }
         quad->ToLinearPathComponents(scale, writer);
         break;
       }
       case ComponentType::kCubic: {
         const CubicPathComponent* cubic =
             reinterpret_cast<const CubicPathComponent*>(
                 &path_points[storage_offset]);
         if (first_point) {
           writer.Write(cubic->p1);
           first_point = false;
         }
         cubic->ToLinearPathComponents(scale, writer);
         break;
       }
       case Path::ComponentType::kContour:
         if (component_i == path_components.size() - 1) {
           // If the last component is a contour, that means it's an empty
           // contour, so skip it.
           continue;
         }
         // The contour component type is the first segment in a contour.
         // Since this should contain the destination (if closed), we
         // can start with this point. If there was already an open
         // contour, or we've reached the end of the verb list, we
         // also close the contour.
         if (started_contour) {
           writer.EndContour();
         }
         started_contour = true;
         first_point = true;
     }
     storage_offset += VerbToOffset(path_component);
   }
   if (started_contour) {
     writer.EndContour();
   }
 }

References impeller::VertexWriter::EndContour(), kContour, kCubic, kLinear, kQuadratic, impeller::LinearPathComponent::p1, impeller::QuadraticPathComponent::p1, impeller::CubicPathComponent::p1, impeller::LinearPathComponent::p2, scale, impeller::QuadraticPathComponent::ToLinearPathComponents(), impeller::CubicPathComponent::ToLinearPathComponents(), VerbToOffset(), and impeller::VertexWriter::Write().

Referenced by impeller::Tessellator::TessellateConvexInternal().

Friends And Related Function Documentation

◆ PathBuilder

friend class PathBuilder

friend

Definition at line 197 of file path.h.

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

impeller/geometry/path.h
impeller/geometry/path.cc

Classes

Public Types

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

Member Enumeration Documentation

◆ ComponentType

Constructor & Destructor Documentation

◆ Path()

◆ ~Path()

Member Function Documentation

◆ CreatePolyline()

◆ EndContour()

◆ GetBoundingBox()

◆ GetComponentCount()

◆ GetContourComponentAtIndex()

◆ GetCubicComponentAtIndex()

◆ GetFillType()

◆ GetLinearComponentAtIndex()

◆ GetQuadraticComponentAtIndex()

◆ GetTransformedBoundingBox()

◆ IsConvex()

◆ IsEmpty()

◆ VerbToOffset()

◆ WritePolyline()

Friends And Related Function Documentation

◆ PathBuilder