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
class	ComponentIterator

struct	Polyline

struct	PolylineContour

Public Types
enum class	ComponentType { kLinear , kQuadratic , kConic , kCubic , kContour }

Public Member Functions
	Path ()

	~Path ()

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

size_t	GetPointCount () const

FillType	GetFillType () const

bool	IsConvex () const

bool	IsEmpty () const

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

ComponentIterator	begin () const

ComponentIterator	end () 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 54 of file path.h.

Member Enumeration Documentation

◆ ComponentType

enum impeller::Path::ComponentType

strong

Enumerator
kLinear
kQuadratic
kConic
kCubic
kContour

Definition at line 56 of file path.h.

                            {
     kLinear,
     kQuadratic,
     kConic,
     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

◆ begin()

Path::ComponentIterator impeller::Path::begin ( ) const

Definition at line 253 of file path.cc.

                                         {
   return ComponentIterator(*this, 0u, 0u);
 }

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

◆ 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 129 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::kConic: {
         const ConicPathComponent* conic =
             reinterpret_cast<const ConicPathComponent*>(
                 &path_points[storage_offset]);
         points += conic->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::ConicPathComponent::CountLinearPathComponents(), impeller::CubicPathComponent::CountLinearPathComponents(), kConic, 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 355 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::kConic: {
         poly_components.push_back({
             .component_start_index = polyline.points->size() - 1,
             .is_curve = true,
         });
         auto* conic = reinterpret_cast<const ConicPathComponent*>(
             &path_points[storage_offset]);
         conic->AppendPolylinePoints(scale, *polyline.points);
         if (!start_direction.has_value()) {
           start_direction = conic->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::ConicPathComponent::AppendPolylinePoints(), impeller::LinearPathComponent::AppendPolylinePoints(), EndContour(), kConic, 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().

◆ end()

Path::ComponentIterator impeller::Path::end ( ) const

Definition at line 257 of file path.cc.

                                       {
   return ComponentIterator(*this, data_->components.size(),
                            data_->points.size());
 }

Referenced by 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 281 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::kConic: {
         auto* conic = reinterpret_cast<const ConicPathComponent*>(
             &path_points[storage_offset]);
         auto maybe_end = conic->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::ConicPathComponent::GetEndDirection(), impeller::CubicPathComponent::GetEndDirection(), kConic, kContour, kCubic, kLinear, kQuadratic, polyline, and VerbToOffset().

Referenced by CreatePolyline().

◆ GetBoundingBox()

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

Definition at line 466 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 92 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().

◆ GetFillType()

FillType impeller::Path::GetFillType ( ) const

Definition at line 110 of file path.cc.

                                  {
   return data_->fill;
 }

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

◆ GetPointCount()

size_t impeller::Path::GetPointCount ( ) const

Definition at line 106 of file path.cc.

                                  {
   return data_->points.size();
 }

◆ GetTransformedBoundingBox()

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

Definition at line 470 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 114 of file path.cc.

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

References impeller::kConvex.

◆ IsEmpty()

bool impeller::Path::IsEmpty ( ) const

Definition at line 118 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 124 of file path.cc.

                                  {
   return data_->single_contour;
 }

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

◆ VerbToOffset()

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

inlinestaticconstexpr

Definition at line 95 of file path.h.

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

References kConic, kContour, kCubic, kLinear, and kQuadratic.

Referenced by impeller::PathBuilder::AddPath(), CountStorage(), CreatePolyline(), EndContour(), impeller::Path::ComponentIterator::operator++(), 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 174 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::kConic: {
         const ConicPathComponent* conic =
             reinterpret_cast<const ConicPathComponent*>(
                 &path_points[storage_offset]);
         if (first_point) {
           writer.Write(conic->p1);
           first_point = false;
         }
         conic->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(), kConic, kContour, kCubic, kLinear, kQuadratic, impeller::LinearPathComponent::p1, impeller::QuadraticPathComponent::p1, impeller::ConicPathComponent::p1, impeller::CubicPathComponent::p1, impeller::LinearPathComponent::p2, scale, impeller::CubicPathComponent::ToLinearPathComponents(), impeller::QuadraticPathComponent::ToLinearPathComponents(), impeller::ConicPathComponent::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 233 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

◆ begin()

◆ CountStorage()

◆ CreatePolyline()

◆ end()

◆ EndContour()

◆ GetBoundingBox()

◆ GetComponentCount()

◆ GetFillType()

◆ GetPointCount()

◆ GetTransformedBoundingBox()

◆ IsConvex()

◆ IsEmpty()

◆ IsSingleContour()

◆ VerbToOffset()

◆ WritePolyline()

Friends And Related Function Documentation

◆ PathBuilder