impeller::ConvexTessellatorImpl< IndexT > Class Template Reference

Inherits impeller::Tessellator::ConvexTessellator.

Public Member Functions
	ConvexTessellatorImpl ()
VertexBuffer	TessellateConvex (const PathSource &path, HostBuffer &data_host_buffer, HostBuffer &indexes_host_buffer, Scalar tolerance, bool supports_primitive_restart, bool supports_triangle_fan) override

Detailed Description

template<typename IndexT>
class impeller::ConvexTessellatorImpl< IndexT >

Definition at line 324 of file tessellator.cc.

Constructor & Destructor Documentation

ConvexTessellatorImpl()

template<typename IndexT >

impeller::ConvexTessellatorImpl< IndexT >::ConvexTessellatorImpl ( )

inline

Definition at line 326 of file tessellator.cc.

                          {
    point_buffer_.reserve(2048);
    index_buffer_.reserve(2048);
  }

Member Function Documentation

TessellateConvex()

template<typename IndexT >

VertexBuffer impeller::ConvexTessellatorImpl< IndexT >::TessellateConvex ( const PathSource &  path, HostBuffer &  data_host_buffer, HostBuffer &  indexes_host_buffer, Scalar  tolerance, bool  supports_primitive_restart, bool  supports_triangle_fan  )

inlineoverride

Definition at line 331 of file tessellator.cc.

                                                                     {
    if (supports_primitive_restart) {
      // Primitive Restart.
      const auto [point_count, contour_count] =
          PathTessellator::CountFillStorage(path, tolerance);
      BufferView point_buffer = data_host_buffer.Emplace(
          nullptr, sizeof(Point) * point_count, alignof(Point));
      BufferView index_buffer = indexes_host_buffer.Emplace(
          nullptr, sizeof(IndexT) * (point_count + contour_count),
          alignof(IndexT));
 
      auto* points_ptr =
          reinterpret_cast<Point*>(point_buffer.GetBuffer()->OnGetContents() +
                                   point_buffer.GetRange().offset);
      auto* indices_ptr =
          reinterpret_cast<IndexT*>(index_buffer.GetBuffer()->OnGetContents() +
                                    index_buffer.GetRange().offset);
 
      auto tessellate_path = [&](auto& writer) {
        PathTessellator::PathToFilledVertices(path, writer, tolerance);
        FML_DCHECK(writer.GetPointCount() <= point_count);
        FML_DCHECK(writer.GetIndexCount() <= (point_count + contour_count));
        point_buffer.GetBuffer()->Flush(point_buffer.GetRange());
        index_buffer.GetBuffer()->Flush(index_buffer.GetRange());
 
        return VertexBuffer{
            .vertex_buffer = std::move(point_buffer),
            .index_buffer = std::move(index_buffer),
            .vertex_count = writer.GetIndexCount(),
            .index_type = IndexTypeFor<IndexT>(),
        };
      };
 
      if (supports_triangle_fan) {
        FanPathVertexWriter writer(points_ptr, indices_ptr);
        return tessellate_path(writer);
      } else {
        StripPathVertexWriter writer(points_ptr, indices_ptr);
        return tessellate_path(writer);
      }
    }
 
    DoTessellateConvexInternal(path, point_buffer_, index_buffer_, tolerance);
 
    if (point_buffer_.empty()) {
      return VertexBuffer{
          .vertex_buffer = {},
          .index_buffer = {},
          .vertex_count = 0u,
          .index_type = IndexTypeFor<IndexT>(),
      };
    }
 
    BufferView vertex_buffer = data_host_buffer.Emplace(
        point_buffer_.data(), sizeof(Point) * point_buffer_.size(),
        alignof(Point));
 
    BufferView index_buffer = indexes_host_buffer.Emplace(
        index_buffer_.data(), sizeof(IndexT) * index_buffer_.size(),
        alignof(IndexT));
 
    return VertexBuffer{
        .vertex_buffer = std::move(vertex_buffer),
        .index_buffer = std::move(index_buffer),
        .vertex_count = index_buffer_.size(),
        .index_type = IndexTypeFor<IndexT>(),
    };
  }

References impeller::PathTessellator::CountFillStorage(), impeller::HostBuffer::Emplace(), impeller::DeviceBuffer::Flush(), impeller::BufferView::GetBuffer(), impeller::BufferView::GetRange(), impeller::Range::offset, impeller::DeviceBuffer::OnGetContents(), impeller::PathTessellator::PathToFilledVertices(), and impeller::VertexBuffer::vertex_buffer.

---

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

• impeller/tessellator/tessellator.cc