impeller::Tessellator Class Reference

A utility that generates triangles of the specified fill type given a polyline. This happens on the CPU. More...

#include <tessellator.h>

Public Types
enum	Result {   Result::kSuccess,   Result::kInputError,   Result::kTessellationError }
using	BuilderCallback = std::function< bool(const float *vertices, size_t vertices_count, const uint16_t *indices, size_t indices_count)>
	A callback that returns the results of the tessellation. More...

Public Member Functions
	Tessellator ()
	~Tessellator ()
Tessellator::Result	Tessellate (FillType fill_type, const Path::Polyline &polyline, const BuilderCallback &callback) const
	Generates filled triangles from the polyline. A callback is invoked once for the entire tessellation. More...

Static Public Attributes
static constexpr size_t	kMultiContourThreshold = 30u
	An arbitrary value to determine when a multi-contour non-zero fill path should be split into multiple tessellations. More...

Detailed Description

A utility that generates triangles of the specified fill type given a polyline. This happens on the CPU.

Definition at line 35 of file tessellator.h.

Member Typedef Documentation

BuilderCallback

using impeller::Tessellator::BuilderCallback = std::function<bool(const float* vertices, size_t vertices_count, const uint16_t* indices, size_t indices_count)>

A callback that returns the results of the tessellation.

   The index buffer may not be populated, in which case [indices] will
   be nullptr and indices_count will be 0. 

Definition at line 58 of file tessellator.h.

Member Enumeration Documentation

Result

enum impeller::Tessellator::Result

strong

Enumerator
kSuccess
kInputError
kTessellationError

Definition at line 37 of file tessellator.h.

                    {
    kSuccess,
    kInputError,
    kTessellationError,
  };

Constructor & Destructor Documentation

Tessellator()

impeller::Tessellator::Tessellator

(

)

Definition at line 34 of file tessellator.cc.

                         : c_tessellator_(nullptr, &DestroyTessellator) {
  TESSalloc alloc = kAlloc;
  {
    // libTess2 copies the TESSalloc despite the non-const argument.
    CTessellator tessellator(::tessNewTess(&alloc), &DestroyTessellator);
    c_tessellator_ = std::move(tessellator);
  }
}

References impeller::DestroyTessellator(), and impeller::kAlloc.

~Tessellator()

impeller::Tessellator::~Tessellator ( )

default

Member Function Documentation

Tessellate()

Tessellator::Result impeller::Tessellator::Tessellate	(	FillType	fill_type,
		const Path::Polyline &	polyline,
		const BuilderCallback &	callback
	)		const

Generates filled triangles from the polyline. A callback is invoked once for the entire tessellation.

Parameters

[in]	fill_type	The fill rule to use when filling.
[in]	polyline	The polyline
[in]	callback	The callback, return false to indicate failure.

Returns

The result status of the tessellation.

Feed contour information to the tessellator.

Let's tessellate.

Feed contour information to the tessellator.

Let's tessellate.

Definition at line 61 of file tessellator.cc.

                                           {
  if (!callback) {
    return Result::kInputError;
  }
 
  if (polyline.points.empty()) {
    return Result::kInputError;
  }
 
  auto tessellator = c_tessellator_.get();
  if (!tessellator) {
    return Result::kTessellationError;
  }
 
  constexpr int kVertexSize = 2;
  constexpr int kPolygonSize = 3;
 
  // If we have a larger polyline and the fill type is non-zero, we can split
  // the tessellation up per contour. Since in general the complexity is at
  // least nlog(n), this speeds up the processes substantially.
  if (polyline.contours.size() > kMultiContourThreshold &&
      fill_type == FillType::kNonZero) {
    std::vector<Point> points;
    std::vector<float> data;
 
    //----------------------------------------------------------------------------
    /// Feed contour information to the tessellator.
    ///
    size_t total = 0u;
    static_assert(sizeof(Point) == 2 * sizeof(float));
    for (size_t contour_i = 0; contour_i < polyline.contours.size();
         contour_i++) {
      size_t start_point_index, end_point_index;
      std::tie(start_point_index, end_point_index) =
          polyline.GetContourPointBounds(contour_i);
 
      ::tessAddContour(tessellator,  // the C tessellator
                       kVertexSize,  //
                       polyline.points.data() + start_point_index,  //
                       sizeof(Point),                               //
                       end_point_index - start_point_index          //
      );
 
      //----------------------------------------------------------------------------
      /// Let's tessellate.
      ///
      auto result = ::tessTesselate(tessellator,  // tessellator
                                    ToTessWindingRule(fill_type),  // winding
                                    TESS_POLYGONS,  // element type
                                    kPolygonSize,   // polygon size
                                    kVertexSize,    // vertex size
                                    nullptr  // normal (null is automatic)
      );
 
      if (result != 1) {
        return Result::kTessellationError;
      }
 
      int vertex_item_count = tessGetVertexCount(tessellator) * kVertexSize;
      auto vertices = tessGetVertices(tessellator);
      for (int i = 0; i < vertex_item_count; i += 2) {
        points.emplace_back(vertices[i], vertices[i + 1]);
      }
 
      int element_item_count = tessGetElementCount(tessellator) * kPolygonSize;
      auto elements = tessGetElements(tessellator);
      total += element_item_count;
      for (int i = 0; i < element_item_count; i++) {
        data.emplace_back(points[elements[i]].x);
        data.emplace_back(points[elements[i]].y);
      }
      points.clear();
    }
    if (!callback(data.data(), total, nullptr, 0u)) {
      return Result::kInputError;
    }
  } else {
    //----------------------------------------------------------------------------
    /// Feed contour information to the tessellator.
    ///
    static_assert(sizeof(Point) == 2 * sizeof(float));
    for (size_t contour_i = 0; contour_i < polyline.contours.size();
         contour_i++) {
      size_t start_point_index, end_point_index;
      std::tie(start_point_index, end_point_index) =
          polyline.GetContourPointBounds(contour_i);
 
      ::tessAddContour(tessellator,  // the C tessellator
                       kVertexSize,  //
                       polyline.points.data() + start_point_index,  //
                       sizeof(Point),                               //
                       end_point_index - start_point_index          //
      );
    }
 
    //----------------------------------------------------------------------------
    /// Let's tessellate.
    ///
    auto result = ::tessTesselate(tessellator,                   // tessellator
                                  ToTessWindingRule(fill_type),  // winding
                                  TESS_POLYGONS,                 // element type
                                  kPolygonSize,                  // polygon size
                                  kVertexSize,                   // vertex size
                                  nullptr  // normal (null is automatic)
    );
 
    if (result != 1) {
      return Result::kTessellationError;
    }
 
    int element_item_count = tessGetElementCount(tessellator) * kPolygonSize;
 
    // We default to using a 16bit index buffer, but in cases where we generate
    // more tessellated data than this can contain we need to fall back to
    // dropping the index buffer entirely. Instead code could instead switch to
    // a uint32 index buffer, but this is done for simplicity with the other
    // fast path above.
    if (element_item_count < USHRT_MAX) {
      int vertex_item_count = tessGetVertexCount(tessellator);
      auto vertices = tessGetVertices(tessellator);
      auto elements = tessGetElements(tessellator);
 
      // libtess uses an int index internally due to usage of -1 as a sentinel
      // value.
      std::vector<uint16_t> indices(element_item_count);
      for (int i = 0; i < element_item_count; i++) {
        indices[i] = static_cast<uint16_t>(elements[i]);
      }
      if (!callback(vertices, vertex_item_count, indices.data(),
                    element_item_count)) {
        return Result::kInputError;
      }
    } else {
      std::vector<Point> points;
      std::vector<float> data;
 
      int vertex_item_count = tessGetVertexCount(tessellator) * kVertexSize;
      auto vertices = tessGetVertices(tessellator);
      for (int i = 0; i < vertex_item_count; i += 2) {
        points.emplace_back(vertices[i], vertices[i + 1]);
      }
 
      int element_item_count = tessGetElementCount(tessellator) * kPolygonSize;
      auto elements = tessGetElements(tessellator);
      for (int i = 0; i < element_item_count; i++) {
        data.emplace_back(points[elements[i]].x);
        data.emplace_back(points[elements[i]].y);
      }
      if (!callback(data.data(), element_item_count, nullptr, 0u)) {
        return Result::kInputError;
      }
    }
  }
 
  return Result::kSuccess;
}

References impeller::Path::Polyline::contours, impeller::Path::Polyline::GetContourPointBounds(), kInputError, kMultiContourThreshold, impeller::kNonZero, kSuccess, kTessellationError, impeller::Path::Polyline::points, and impeller::ToTessWindingRule().

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

Member Data Documentation

kMultiContourThreshold

constexpr size_t impeller::Tessellator::kMultiContourThreshold = 30u

staticconstexpr

An arbitrary value to determine when a multi-contour non-zero fill path should be split into multiple tessellations.

Definition at line 49 of file tessellator.h.

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

---

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

• impeller/tessellator/tessellator.h
• impeller/tessellator/tessellator.cc