impeller::ComputeTessellator Class Reference

A utility that generates triangles of the specified fill type given a path. More...

#include <compute_tessellator.h>

Public Types
enum	Status {   Status::kCommandInvalid,   Status::kTooManyComponents,   Status::kOk }
enum	Style { Style::kStroke }

Public Member Functions
	ComputeTessellator ()
	~ComputeTessellator ()
ComputeTessellator &	SetStyle (Style value)
ComputeTessellator &	SetStrokeWidth (Scalar value)
ComputeTessellator &	SetStrokeJoin (Join value)
ComputeTessellator &	SetStrokeCap (Cap value)
ComputeTessellator &	SetMiterLimit (Scalar value)
ComputeTessellator &	SetCubicAccuracy (Scalar value)
ComputeTessellator &	SetQuadraticTolerance (Scalar value)
Status	Tessellate (const Path &path, const std::shared_ptr< Context > &context, BufferView vertex_buffer, BufferView vertex_buffer_count, const CommandBuffer::CompletionCallback &callback=nullptr) const
	Generates triangles from the path. If the data needs to be synchronized back to the CPU, e.g. because one of the buffer views are host visible and will be used without creating a blit pass to copy them back, the callback is used to determine when the GPU calculation is complete and its status. On Metal, no additional synchronization is needed as long as the buffers are not heap allocated, so no additional synchronization mechanism is provided. More...

Static Public Attributes
static constexpr size_t	kMaxCubicCount = 512
static constexpr size_t	kMaxQuadCount = 2048
static constexpr size_t	kMaxLineCount = 4096
static constexpr size_t	kMaxComponentCount

Detailed Description

A utility that generates triangles of the specified fill type given a path.

Definition at line 19 of file compute_tessellator.h.

Member Enumeration Documentation

Status

enum impeller::ComputeTessellator::Status

strong

Enumerator
kCommandInvalid
kTooManyComponents
kOk

Definition at line 31 of file compute_tessellator.h.

                    {
    kCommandInvalid,
    kTooManyComponents,
    kOk,
  };

Style

enum impeller::ComputeTessellator::Style

strong

Enumerator
kStroke

Definition at line 37 of file compute_tessellator.h.

                   {
    kStroke,
    // TODO(dnfield): Implement kFill.
  };

Constructor & Destructor Documentation

ComputeTessellator()

impeller::ComputeTessellator::ComputeTessellator ( )

default

~ComputeTessellator()

impeller::ComputeTessellator::~ComputeTessellator ( )

default

Member Function Documentation

SetCubicAccuracy()

ComputeTessellator & impeller::ComputeTessellator::SetCubicAccuracy

(

Scalar

value

)

Definition at line 52 of file compute_tessellator.cc.

                                                                     {
  cubic_accuracy_ = value;
  return *this;
}

SetMiterLimit()

ComputeTessellator & impeller::ComputeTessellator::SetMiterLimit

(

Scalar

value

)

Definition at line 48 of file compute_tessellator.cc.

                                                                  {
  miter_limit_ = value;
  return *this;
}

SetQuadraticTolerance()

ComputeTessellator & impeller::ComputeTessellator::SetQuadraticTolerance

(

Scalar

value

)

Definition at line 56 of file compute_tessellator.cc.

                                                                          {
  quad_tolerance_ = value;
  return *this;
}

SetStrokeCap()

ComputeTessellator & impeller::ComputeTessellator::SetStrokeCap

(

Cap

value

)

Definition at line 44 of file compute_tessellator.cc.

                                                              {
  stroke_cap_ = value;
  return *this;
}

SetStrokeJoin()

ComputeTessellator & impeller::ComputeTessellator::SetStrokeJoin

(

Join

value

)

Definition at line 40 of file compute_tessellator.cc.

                                                                {
  stroke_join_ = value;
  return *this;
}

SetStrokeWidth()

ComputeTessellator & impeller::ComputeTessellator::SetStrokeWidth

(

Scalar

value

)

Definition at line 35 of file compute_tessellator.cc.

                                                                   {
  stroke_width_ = value;
  return *this;
}

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

SetStyle()

ComputeTessellator & impeller::ComputeTessellator::SetStyle

(

Style

value

)

Definition at line 30 of file compute_tessellator.cc.

                                                            {
  style_ = value;
  return *this;
}

Tessellate()

ComputeTessellator::Status impeller::ComputeTessellator::Tessellate	(	const Path &	path,
		const std::shared_ptr< Context > &	context,
		BufferView	vertex_buffer,
		BufferView	vertex_buffer_count,
		const CommandBuffer::CompletionCallback &	callback = nullptr
	)		const

Generates triangles from the path. If the data needs to be synchronized back to the CPU, e.g. because one of the buffer views are host visible and will be used without creating a blit pass to copy them back, the callback is used to determine when the GPU calculation is complete and its status. On Metal, no additional synchronization is needed as long as the buffers are not heap allocated, so no additional synchronization mechanism is provided.

Returns

A |Status| value indicating success or failure of the submission.

Definition at line 61 of file compute_tessellator.cc.

                                                           {
  FML_DCHECK(style_ == Style::kStroke);
  using PS = PathPolylineComputeShader;
  using SS = StrokeComputeShader;
 
  auto cubic_count = path.GetComponentCount(Path::ComponentType::kCubic);
  auto quad_count = path.GetComponentCount(Path::ComponentType::kQuadratic) +
                    (cubic_count * 6);
  auto line_count =
      path.GetComponentCount(Path::ComponentType::kLinear) + (quad_count * 6);
  if (cubic_count > kMaxCubicCount || quad_count > kMaxQuadCount ||
      line_count > kMaxLineCount) {
    return Status::kTooManyComponents;
  }
  PS::Cubics<kMaxCubicCount> cubics{.count = 0};
  PS::Quads<kMaxQuadCount> quads{.count = 0};
  PS::Lines<kMaxLineCount> lines{.count = 0};
  PS::Components<kMaxComponentCount> components{.count = 0};
  PS::Config config{.cubic_accuracy = cubic_accuracy_,
                    .quad_tolerance = quad_tolerance_};
 
  path.EnumerateComponents(
      [&lines, &components](size_t index, const LinearPathComponent& linear) {
        ::memcpy(&lines.data[lines.count], &linear,
                 sizeof(LinearPathComponent));
        components.data[components.count++] = {lines.count++, 2};
      },
      [&quads, &components](size_t index, const QuadraticPathComponent& quad) {
        ::memcpy(&quads.data[quads.count], &quad,
                 sizeof(QuadraticPathComponent));
        components.data[components.count++] = {quads.count++, 3};
      },
      [&cubics, &components](size_t index, const CubicPathComponent& cubic) {
        ::memcpy(&cubics.data[cubics.count], &cubic,
                 sizeof(CubicPathComponent));
        components.data[components.count++] = {cubics.count++, 4};
      },
      [](size_t index, const ContourComponent& contour) {});
 
  auto polyline_buffer =
      CreateDeviceBuffer<PS::Polyline<2048>>(context, "Polyline");
 
  auto cmd_buffer = context->CreateCommandBuffer();
  auto pass = cmd_buffer->CreateComputePass();
  FML_DCHECK(pass && pass->IsValid());
 
  {
    using PathPolylinePipelineBuilder = ComputePipelineBuilder<PS>;
    auto pipeline_desc =
        PathPolylinePipelineBuilder::MakeDefaultPipelineDescriptor(*context);
    FML_DCHECK(pipeline_desc.has_value());
    auto compute_pipeline =
        context->GetPipelineLibrary()->GetPipeline(pipeline_desc).Get();
    FML_DCHECK(compute_pipeline);
 
    pass->SetGridSize(ISize(line_count, 1));
    pass->SetThreadGroupSize(ISize(line_count, 1));
 
    ComputeCommand cmd;
    DEBUG_COMMAND_INFO(cmd, "Generate Polyline");
    cmd.pipeline = compute_pipeline;
 
    PS::BindConfig(cmd, pass->GetTransientsBuffer().EmplaceUniform(config));
    PS::BindCubics(cmd,
                   pass->GetTransientsBuffer().EmplaceStorageBuffer(cubics));
    PS::BindQuads(cmd, pass->GetTransientsBuffer().EmplaceStorageBuffer(quads));
    PS::BindLines(cmd, pass->GetTransientsBuffer().EmplaceStorageBuffer(lines));
    PS::BindComponents(
        cmd, pass->GetTransientsBuffer().EmplaceStorageBuffer(components));
    PS::BindPolyline(cmd, polyline_buffer->AsBufferView());
 
    if (!pass->AddCommand(std::move(cmd))) {
      return Status::kCommandInvalid;
    }
  }
 
  {
    using StrokePipelineBuilder = ComputePipelineBuilder<SS>;
    auto pipeline_desc =
        StrokePipelineBuilder::MakeDefaultPipelineDescriptor(*context);
    FML_DCHECK(pipeline_desc.has_value());
    auto compute_pipeline =
        context->GetPipelineLibrary()->GetPipeline(pipeline_desc).Get();
    FML_DCHECK(compute_pipeline);
 
    pass->SetGridSize(ISize(line_count, 1));
    pass->SetThreadGroupSize(ISize(line_count, 1));
 
    ComputeCommand cmd;
    DEBUG_COMMAND_INFO(cmd, "Compute Stroke");
    cmd.pipeline = compute_pipeline;
 
    SS::Config config{
        .width = stroke_width_,
        .cap = static_cast<uint32_t>(stroke_cap_),
        .join = static_cast<uint32_t>(stroke_join_),
        .miter_limit = miter_limit_,
    };
    SS::BindConfig(cmd, pass->GetTransientsBuffer().EmplaceUniform(config));
 
    SS::BindPolyline(cmd, polyline_buffer->AsBufferView());
    SS::BindVertexBufferCount(cmd, std::move(vertex_buffer_count));
    SS::BindVertexBuffer(cmd, std::move(vertex_buffer));
 
    if (!pass->AddCommand(std::move(cmd))) {
      return Status::kCommandInvalid;
    }
  }
 
  if (!pass->EncodeCommands()) {
    return Status::kCommandInvalid;
  }
 
  if (!cmd_buffer->SubmitCommands(callback)) {
    return Status::kCommandInvalid;
  }
 
  return Status::kOk;
}

References DEBUG_COMMAND_INFO, impeller::Path::EnumerateComponents(), impeller::Path::GetComponentCount(), kCommandInvalid, impeller::Path::kCubic, impeller::Path::kLinear, kMaxCubicCount, kMaxLineCount, kMaxQuadCount, kOk, impeller::Path::kQuadratic, kStroke, kTooManyComponents, and impeller::ComputeCommand::pipeline.

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

Member Data Documentation

kMaxComponentCount

constexpr size_t impeller::ComputeTessellator::kMaxComponentCount

staticconstexpr

Initial value:

=
      kMaxCubicCount + kMaxQuadCount + kMaxLineCount

Definition at line 28 of file compute_tessellator.h.

kMaxCubicCount

constexpr size_t impeller::ComputeTessellator::kMaxCubicCount = 512

staticconstexpr

Definition at line 25 of file compute_tessellator.h.

Referenced by Tessellate().

kMaxLineCount

constexpr size_t impeller::ComputeTessellator::kMaxLineCount = 4096

staticconstexpr

Definition at line 27 of file compute_tessellator.h.

Referenced by Tessellate().

kMaxQuadCount

constexpr size_t impeller::ComputeTessellator::kMaxQuadCount = 2048

staticconstexpr

Definition at line 26 of file compute_tessellator.h.

Referenced by Tessellate().

---

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

• impeller/renderer/compute_tessellator.h
• impeller/renderer/compute_tessellator.cc