impeller::TessellatorLibtess Class Reference

An extended tessellator that offers arbitrary/concave tessellation via the libtess2 library. More...

#include <tessellator_libtess.h>

Inheritance diagram for impeller::TessellatorLibtess:

Public Types
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.
Public Types inherited from impeller::Tessellator
enum class	Result { kSuccess , kInputError , kTessellationError }
using	TessellatedVertexProc = std::function< void(const Point &p)>
	A callback function for a |VertexGenerator| to deliver the vertices it computes as |Point| objects.

Public Member Functions
	TessellatorLibtess ()
	~TessellatorLibtess ()
Tessellator::Result	Tessellate (const Path &path, Scalar tolerance, const BuilderCallback &callback)
	Generates filled triangles from the path. A callback is invoked once for the entire tessellation.
Public Member Functions inherited from impeller::Tessellator
	Tessellator ()
virtual	~Tessellator ()
std::vector< Point >	TessellateConvex (const Path &path, Scalar tolerance)
	Given a convex path, create a triangle fan structure.
Path::Polyline	CreateTempPolyline (const Path &path, Scalar tolerance)
	Create a temporary polyline. Only one per-process can exist at a time.
EllipticalVertexGenerator	FilledCircle (const Matrix &view_transform, const Point &center, Scalar radius)
	Create a |VertexGenerator| that can produce vertices for a filled circle of the given radius around the given center with enough polygon sub-divisions to provide reasonable fidelity when viewed under the given view transform.
EllipticalVertexGenerator	StrokedCircle (const Matrix &view_transform, const Point &center, Scalar radius, Scalar half_width)
	Create a |VertexGenerator| that can produce vertices for a stroked circle of the given radius and half_width around the given shared center with enough polygon sub-divisions to provide reasonable fidelity when viewed under the given view transform. The outer edge of the stroked circle is generated at (radius + half_width) and the inner edge is generated at (radius - half_width).
EllipticalVertexGenerator	RoundCapLine (const Matrix &view_transform, const Point &p0, const Point &p1, Scalar radius)
	Create a |VertexGenerator| that can produce vertices for a line with round end caps of the given radius with enough polygon sub-divisions to provide reasonable fidelity when viewed under the given view transform.
EllipticalVertexGenerator	FilledEllipse (const Matrix &view_transform, const Rect &bounds)
	Create a |VertexGenerator| that can produce vertices for a filled ellipse inscribed within the given bounds with enough polygon sub-divisions to provide reasonable fidelity when viewed under the given view transform.
EllipticalVertexGenerator	FilledRoundRect (const Matrix &view_transform, const Rect &bounds, const Size &radii)
	Create a |VertexGenerator| that can produce vertices for a filled round rect within the given bounds and corner radii with enough polygon sub-divisions to provide reasonable fidelity when viewed under the given view transform.

Additional Inherited Members
Static Public Attributes inherited from impeller::Tessellator
static constexpr Scalar	kCircleTolerance = 0.1f
	The pixel tolerance used by the algorighm to determine how many divisions to create for a circle.
Protected Attributes inherited from impeller::Tessellator
std::unique_ptr< std::vector< Point > >	point_buffer_
	Used for polyline generation.

Detailed Description

An extended tessellator that offers arbitrary/concave tessellation via the libtess2 library.

This object is not thread safe, and its methods must not be called from multiple threads.

Definition at line 30 of file tessellator_libtess.h.

Member Typedef Documentation

BuilderCallback

using impeller::TessellatorLibtess::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 40 of file tessellator_libtess.h.

Constructor & Destructor Documentation

TessellatorLibtess()

impeller::TessellatorLibtess::TessellatorLibtess

(

)

Definition at line 34 of file tessellator_libtess.cc.

    : Tessellator(), 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);
  }
}

~TessellatorLibtess()

impeller::TessellatorLibtess::~TessellatorLibtess ( )

default

Member Function Documentation

Tessellate()

TessellatorLibtess::Result impeller::TessellatorLibtess::Tessellate	(	const Path &	path,
		Scalar	tolerance,
		const BuilderCallback &	callback
	)

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

Parameters

[in]	path	The path to tessellate.
[in]	tolerance	The tolerance value for conversion of the path to a polyline. This value is often derived from the Matrix::GetMaxBasisLength of the CTM applied to the path for rendering.
[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.

Definition at line 56 of file tessellator_libtess.cc.

                                     {
  if (!callback) {
    return Result::kInputError;
  }
 
  point_buffer_->clear();
  auto polyline =
      path.CreatePolyline(tolerance, std::move(point_buffer_),
                          [this](Path::Polyline::PointBufferPtr point_buffer) {
                            point_buffer_ = std::move(point_buffer);
                          });
 
  auto fill_type = path.GetFillType();
 
  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;
 
  //----------------------------------------------------------------------------
  /// 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);
    points.reserve(vertex_item_count);
    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);
    data.reserve(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);
    }
    if (!callback(data.data(), element_item_count, nullptr, 0u)) {
      return Result::kInputError;
    }
  }
 
  return Result::kSuccess;
}

---

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

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