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 class	ComponentType { kLinear , kQuadratic , kCubic , kContour }

Public Member Functions
	Path ()

	~Path ()

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

FillType	GetFillType () const

bool	IsConvex () const

bool	IsEmpty () const

bool	IsSingleContour () const
	Whether the line contains a single contour. More...

ComponentType	GetComponentTypeAtIndex (size_t index) 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

std::pair< size_t, size_t >	CountStorage (Scalar scale) const
	Determine required storage for points and number of contours. More...

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 53 of file path.h.

Member Enumeration Documentation

◆ ComponentType

enum impeller::Path::ComponentType

strong

Enumerator
kLinear
kQuadratic
kCubic
kContour

Definition at line 55 of file path.h.

                            {
     kLinear,
     kQuadratic,
     kCubic,
     kContour,
   };

Constructor & Destructor Documentation

◆ Path()

impeller::Path::Path ( )

Definition at line 16 of file path.cc.

16 : data_(new Data()) {}

◆ ~Path()

impeller::Path::~Path ( )

default

Member Function Documentation

◆ CountStorage()

std::pair< size_t, size_t > impeller::Path::CountStorage ( Scalar scale ) const

Determine required storage for points and number of contours.

Determine required storage for points and indices.

Definition at line 67 of file path.cc.

                                                              {
   size_t points = 0;
   size_t contours = 0;
  
   auto& path_components = data_->components;
   auto& path_points = data_->points;
  
   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: {
         points += 2;
         break;
       }
       case ComponentType::kQuadratic: {
         const QuadraticPathComponent* quad =
             reinterpret_cast<const QuadraticPathComponent*>(
                 &path_points[storage_offset]);
         points += quad->CountLinearPathComponents(scale);
         break;
       }
       case ComponentType::kCubic: {
         const CubicPathComponent* cubic =
             reinterpret_cast<const CubicPathComponent*>(
                 &path_points[storage_offset]);
         points += cubic->CountLinearPathComponents(scale);
         break;
       }
       case Path::ComponentType::kContour:
         contours++;
     }
     storage_offset += VerbToOffset(path_component);
   }
   return std::make_pair(points, contours);
 }

References impeller::QuadraticPathComponent::CountLinearPathComponents(), impeller::CubicPathComponent::CountLinearPathComponents(), kContour, kCubic, kLinear, kQuadratic, scale, and VerbToOffset().

Referenced by impeller::Tessellator::TessellateConvex(), and impeller::testing::TEST().

◆ 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 338 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::CubicPathComponent::AppendPolylinePoints(), impeller::QuadraticPathComponent::AppendPolylinePoints(), impeller::LinearPathComponent::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 274 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 436 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 34 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().

◆ GetComponentTypeAtIndex()

Path::ComponentType impeller::Path::GetComponentTypeAtIndex ( size_t index ) const

Definition at line 173 of file path.cc.

                                                                   {
   auto& components = data_->components;
   return components[index];
 }

◆ GetContourComponentAtIndex()

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

Definition at line 237 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 217 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 48 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 178 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 196 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 440 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 52 of file path.cc.

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

References impeller::kConvex.

◆ IsEmpty()

bool impeller::Path::IsEmpty ( ) const

Definition at line 56 of file path.cc.

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

References kContour.

◆ IsSingleContour()

bool impeller::Path::IsSingleContour ( ) const

Whether the line contains a single contour.

Definition at line 62 of file path.cc.

                                  {
   return data_->single_countour;
 }

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

◆ VerbToOffset()

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

inlinestaticconstexpr

Definition at line 62 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(), CountStorage(), 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 105 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::CubicPathComponent::ToLinearPathComponents(), impeller::QuadraticPathComponent::ToLinearPathComponents(), VerbToOffset(), and impeller::VertexWriter::Write().

Referenced by impeller::Tessellator::GenerateLineStrip(), impeller::Tessellator::TessellateConvex(), impeller::Tessellator::TessellateConvexInternal(), and impeller::testing::TEST().

Friends And Related Function Documentation

◆ PathBuilder

friend class PathBuilder

friend

Definition at line 206 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

◆ CountStorage()

◆ CreatePolyline()

◆ EndContour()

◆ GetBoundingBox()

◆ GetComponentCount()

◆ GetComponentTypeAtIndex()

◆ GetContourComponentAtIndex()

◆ GetCubicComponentAtIndex()

◆ GetFillType()

◆ GetLinearComponentAtIndex()

◆ GetQuadraticComponentAtIndex()

◆ GetTransformedBoundingBox()

◆ IsConvex()

◆ IsEmpty()

◆ IsSingleContour()

◆ VerbToOffset()

◆ WritePolyline()

Friends And Related Function Documentation

◆ PathBuilder