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 }

template<class T >
using	Applier = std::function< void(size_t index, const T &component)>

Public Member Functions
	Path ()

	~Path ()

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

FillType	GetFillType () const

bool	IsConvex () const

bool	IsEmpty () const

void	EnumerateComponents (const Applier< LinearPathComponent > &linear_applier, const Applier< QuadraticPathComponent > &quad_applier, const Applier< CubicPathComponent > &cubic_applier, const Applier< ContourComponent > &contour_applier) 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

std::optional< Rect >	GetBoundingBox () const

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

void	WritePolyline (Scalar scale, VertexWriter &writer) const

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 Typedef Documentation

◆ Applier

template<class T >

using impeller::Path::Applier = std::function<void(size_t index, const T& component)>

Definition at line 142 of file path.h.

Member Enumeration Documentation

◆ ComponentType

enum class 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 16 of file path.cc.

16: data_(new Data()) {}

flutter::Data

struct PathData * Data(SkPath *path)

Definition: path_ops.cc:52

◆ ~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 264 of file path.cc.

                                                          {
  Polyline polyline(std::move(point_buffer), std::move(reclaim));
 
  auto& path_components = data_->components;
  auto& path_points = data_->points;
 
  auto get_path_component = [&path_components, &path_points](
                                size_t component_i) -> PathComponentVariant {
    if (component_i >= path_components.size()) {
      return std::monostate{};
    }
    const auto& component = path_components[component_i];
    switch (component.type) {
      case ComponentType::kLinear:
        return reinterpret_cast<const LinearPathComponent*>(
            &path_points[component.index]);
      case ComponentType::kQuadratic:
        return reinterpret_cast<const QuadraticPathComponent*>(
            &path_points[component.index]);
      case ComponentType::kCubic:
        return reinterpret_cast<const CubicPathComponent*>(
            &path_points[component.index]);
      case ComponentType::kContour:
        return std::monostate{};
    }
  };
 
  auto compute_contour_start_direction =
      [&get_path_component](size_t current_path_component_index) {
        size_t next_component_index = current_path_component_index + 1;
        while (!std::holds_alternative<std::monostate>(
            get_path_component(next_component_index))) {
          auto next_component = get_path_component(next_component_index);
          auto maybe_vector =
              std::visit(PathComponentStartDirectionVisitor(), next_component);
          if (maybe_vector.has_value()) {
            return maybe_vector.value();
          } else {
            next_component_index++;
          }
        }
        return Vector2(0, -1);
      };
 
  std::vector<PolylineContour::Component> poly_components;
  std::optional<size_t> previous_path_component_index;
  auto end_contour = [&polyline, &previous_path_component_index,
                      &get_path_component, &poly_components]() {
    // Whenever a contour has ended, extract the exact end direction from
    // the last component.
    if (polyline.contours.empty()) {
      return;
    }
 
    if (!previous_path_component_index.has_value()) {
      return;
    }
 
    auto& contour = polyline.contours.back();
    contour.end_direction = Vector2(0, 1);
    contour.components = poly_components;
    poly_components.clear();
 
    size_t previous_index = previous_path_component_index.value();
    while (!std::holds_alternative<std::monostate>(
        get_path_component(previous_index))) {
      auto previous_component = get_path_component(previous_index);
      auto maybe_vector =
          std::visit(PathComponentEndDirectionVisitor(), previous_component);
      if (maybe_vector.has_value()) {
        contour.end_direction = maybe_vector.value();
        break;
      } else {
        if (previous_index == 0) {
          break;
        }
        previous_index--;
      }
    }
  };
 
  for (size_t component_i = 0; component_i < path_components.size();
       component_i++) {
    const auto& path_component = path_components[component_i];
    switch (path_component.type) {
      case ComponentType::kLinear:
        poly_components.push_back({
            .component_start_index = polyline.points->size() - 1,
            .is_curve = false,
        });
        reinterpret_cast<const LinearPathComponent*>(
            &path_points[path_component.index])
            ->AppendPolylinePoints(*polyline.points);
        previous_path_component_index = component_i;
        break;
      case ComponentType::kQuadratic:
        poly_components.push_back({
            .component_start_index = polyline.points->size() - 1,
            .is_curve = true,
        });
        reinterpret_cast<const QuadraticPathComponent*>(
            &path_points[path_component.index])
            ->AppendPolylinePoints(scale, *polyline.points);
        previous_path_component_index = component_i;
        break;
      case ComponentType::kCubic:
        poly_components.push_back({
            .component_start_index = polyline.points->size() - 1,
            .is_curve = true,
        });
        reinterpret_cast<const CubicPathComponent*>(
            &path_points[path_component.index])
            ->AppendPolylinePoints(scale, *polyline.points);
        previous_path_component_index = component_i;
        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.
          continue;
        }
        end_contour();
 
        Vector2 start_direction = compute_contour_start_direction(component_i);
        const auto& contour = data_->contours[path_component.index];
        polyline.contours.push_back({.start_index = polyline.points->size(),
                                     .is_closed = contour.is_closed,
                                     .start_direction = start_direction,
                                     .components = poly_components});
 
        polyline.points->push_back(contour.destination);
        break;
    }
  }
  end_contour();
  return polyline;
}

◆ EnumerateComponents()

void impeller::Path::EnumerateComponents	(	const Applier< LinearPathComponent > &	linear_applier,
		const Applier< QuadraticPathComponent > &	quad_applier,
		const Applier< CubicPathComponent > &	cubic_applier,
		const Applier< ContourComponent > &	contour_applier
	)		const

Definition at line 63 of file path.cc.

                                                            {
  auto& points = data_->points;
  size_t currentIndex = 0;
  for (const auto& component : data_->components) {
    switch (component.type) {
      case ComponentType::kLinear:
        if (linear_applier) {
          linear_applier(currentIndex,
                         LinearPathComponent(points[component.index],
                                             points[component.index + 1]));
        }
        break;
      case ComponentType::kQuadratic:
        if (quad_applier) {
          quad_applier(currentIndex,
                       QuadraticPathComponent(points[component.index],
                                              points[component.index + 1],
                                              points[component.index + 2]));
        }
        break;
      case ComponentType::kCubic:
        if (cubic_applier) {
          cubic_applier(currentIndex,
                        CubicPathComponent(points[component.index],
                                           points[component.index + 1],
                                           points[component.index + 2],
                                           points[component.index + 3]));
        }
        break;
      case ComponentType::kContour:
        if (contour_applier) {
          contour_applier(currentIndex, data_->contours[component.index]);
        }
        break;
    }
    currentIndex++;
  }
}

◆ GetBoundingBox()

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

Definition at line 405 of file path.cc.

                                             {
  return data_->bounds;
}

◆ 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();
  if (type_value == ComponentType::kContour) {
    return data_->contours.size();
  }
  size_t count = 0u;
  for (const auto& component : data_->components) {
    if (component.type == type_value) {
      count++;
    }
  }
  return count;
}

◆ GetContourComponentAtIndex()

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

Definition at line 229 of file path.cc.

                                                                    {
  auto& components = data_->components;
 
  if (index >= components.size()) {
    return false;
  }
 
  if (components[index].type != ComponentType::kContour) {
    return false;
  }
 
  move = data_->contours[components[index].index];
  return true;
}

◆ GetCubicComponentAtIndex()

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

Definition at line 210 of file path.cc.

                                                                     {
  auto& components = data_->components;
 
  if (index >= components.size()) {
    return false;
  }
 
  if (components[index].type != ComponentType::kCubic) {
    return false;
  }
 
  auto& points = data_->points;
  auto point_index = components[index].index;
  cubic = CubicPathComponent(points[point_index], points[point_index + 1],
                             points[point_index + 2], points[point_index + 3]);
  return true;
}

◆ GetFillType()

FillType impeller::Path::GetFillType ( ) const

Definition at line 51 of file path.cc.

                                 {
  return data_->fill;
}

◆ GetLinearComponentAtIndex()

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

Definition at line 172 of file path.cc.

                                                                        {
  auto& components = data_->components;
 
  if (index >= components.size()) {
    return false;
  }
 
  if (components[index].type != ComponentType::kLinear) {
    return false;
  }
 
  auto& points = data_->points;
  auto point_index = components[index].index;
  linear = LinearPathComponent(points[point_index], points[point_index + 1]);
  return true;
}

◆ GetQuadraticComponentAtIndex()

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

Definition at line 190 of file path.cc.

                                             {
  auto& components = data_->components;
 
  if (index >= components.size()) {
    return false;
  }
 
  if (components[index].type != ComponentType::kQuadratic) {
    return false;
  }
 
  auto& points = data_->points;
  auto point_index = components[index].index;
  quadratic = QuadraticPathComponent(
      points[point_index], points[point_index + 1], points[point_index + 2]);
  return true;
}

◆ GetTransformedBoundingBox()

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

Definition at line 409 of file path.cc.

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

◆ IsConvex()

bool impeller::Path::IsConvex ( ) const

Definition at line 55 of file path.cc.

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

◆ IsEmpty()

bool impeller::Path::IsEmpty ( ) const

Definition at line 59 of file path.cc.

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

◆ 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 106 of file path.cc.

                                                                 {
  auto& path_components = data_->components;
  auto& path_points = data_->points;
  bool started_contour = false;
  bool first_point = true;
 
  for (size_t component_i = 0; component_i < path_components.size();
       component_i++) {
    const auto& path_component = path_components[component_i];
    switch (path_component.type) {
      case ComponentType::kLinear: {
        const LinearPathComponent* linear =
            reinterpret_cast<const LinearPathComponent*>(
                &path_points[path_component.index]);
        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[path_component.index]);
        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[path_component.index]);
        if (first_point) {
          writer.Write(cubic->p1);
          first_point = false;
        }
        cubic->ToLinearPathComponents(scale, writer);
        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.
          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;
    }
  }
  if (started_contour) {
    writer.EndContour();
  }
}

Friends And Related Function Documentation

◆ PathBuilder

friend class PathBuilder

friend

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

Friends