impeller/entity/contents/solid_stroke_contents.cc - mirrors/engine - Git at Google

 // Copyright 2013 The Flutter Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "solid_stroke_contents.h"

 #include <optional>

 #include "impeller/entity/contents/clip_contents.h"
 #include "impeller/entity/contents/content_context.h"
 #include "impeller/entity/entity.h"
 #include "impeller/geometry/path_builder.h"
 #include "impeller/renderer/render_pass.h"

 namespace impeller {

 SolidStrokeContents::SolidStrokeContents() {
   SetStrokeCap(Cap::kButt);
   SetStrokeJoin(Join::kMiter);
 }

 SolidStrokeContents::~SolidStrokeContents() = default;

 void SolidStrokeContents::SetColor(Color color) {
   color_ = color;
 }

 const Color& SolidStrokeContents::GetColor() const {
   return color_;
 }

 void SolidStrokeContents::SetPath(Path path) {
   path_ = std::move(path);
 }

 std::optional<Rect> SolidStrokeContents::GetCoverage(
     const Entity& entity) const {
   if (color_.IsTransparent()) {
     return std::nullopt;
   }

   auto path_bounds = path_.GetBoundingBox();
   if (!path_bounds.has_value()) {
     return std::nullopt;
   }
   auto path_coverage = path_bounds->TransformBounds(entity.GetTransformation());

   Scalar max_radius = 0.5;
   if (cap_ == Cap::kSquare) {
     max_radius = max_radius * kSqrt2;
   }
   if (join_ == Join::kMiter) {
     max_radius = std::max(max_radius, miter_limit_ * 0.5f);
   }
   Scalar determinant = entity.GetTransformation().GetDeterminant();
   if (determinant == 0) {
     return std::nullopt;
   }
   Scalar min_size = 1.0f / sqrt(std::abs(determinant));
   Vector2 max_radius_xy = entity.GetTransformation().TransformDirection(
       Vector2(max_radius, max_radius) * std::max(stroke_size_, min_size));

   return Rect(path_coverage.origin - max_radius_xy,
               Size(path_coverage.size.width + max_radius_xy.x * 2,
                    path_coverage.size.height + max_radius_xy.y * 2));
 }

 static VertexBuffer CreateSolidStrokeVertices(
     const Path& path,
     HostBuffer& buffer,
     const SolidStrokeContents::CapProc& cap_proc,
     const SolidStrokeContents::JoinProc& join_proc,
     Scalar miter_limit,
     const SmoothingApproximation& smoothing) {
   using VS = SolidStrokeVertexShader;

   VertexBufferBuilder<VS::PerVertexData> vtx_builder;
   auto polyline = path.CreatePolyline();

   VS::PerVertexData vtx;

   // Normal state.
   Point normal;
   Point previous_normal;  // Used for computing joins.

   auto compute_normal = [&polyline, &normal, &previous_normal](size_t point_i) {
     previous_normal = normal;
     Point direction =
         (polyline.points[point_i] - polyline.points[point_i - 1]).Normalize();
     normal = {-direction.y, direction.x};
   };

   for (size_t contour_i = 0; contour_i < polyline.contours.size();
        contour_i++) {
     size_t contour_start_point_i, contour_end_point_i;
     std::tie(contour_start_point_i, contour_end_point_i) =
         polyline.GetContourPointBounds(contour_i);

     switch (contour_end_point_i - contour_start_point_i) {
       case 1: {
         Point p = polyline.points[contour_start_point_i];
         cap_proc(vtx_builder, p, {-1, 0}, smoothing);
         cap_proc(vtx_builder, p, {1, 0}, smoothing);
         continue;
       }
       case 0:
         continue;  // This contour has no renderable content.
       default:
         break;
     }

     // The first point's normal is always the same as
     compute_normal(contour_start_point_i + 1);
     const Point contour_first_normal = normal;

     if (contour_i > 0) {
       // This branch only executes when we've just finished drawing a contour
       // and are switching to a new one.
       // We're drawing a triangle strip, so we need to "pick up the pen" by
       // appending transparent vertices between the end of the previous contour
       // and the beginning of the new contour.
       vtx.position = polyline.points[contour_start_point_i - 1];
       vtx.normal = {};
       vtx.pen_down = 0.0;
       // Append two transparent vertices when "picking up" the pen so that the
       // triangle drawn when moving to the beginning of the new contour will
       // have zero volume. This is necessary because strokes with a transparent
       // color affect the stencil buffer to prevent overdraw.
       vtx_builder.AppendVertex(vtx);
       vtx_builder.AppendVertex(vtx);

       vtx.position = polyline.points[contour_start_point_i];
       // Append two vertices at the beginning of the new contour
       // so that the next appended vertex will create a triangle with zero
       // volume.
       vtx_builder.AppendVertex(vtx);
       vtx.pen_down = 1.0;
       vtx_builder.AppendVertex(vtx);
     }

     // Generate start cap.
     if (!polyline.contours[contour_i].is_closed) {
       cap_proc(vtx_builder, polyline.points[contour_start_point_i], -normal,
                smoothing);
     }

     // Generate contour geometry.
     for (size_t point_i = contour_start_point_i; point_i < contour_end_point_i;
          point_i++) {
       if (point_i > contour_start_point_i) {
         // Generate line rect.
         vtx.position = polyline.points[point_i - 1];
         vtx.pen_down = 1.0;
         vtx.normal = normal;
         vtx_builder.AppendVertex(vtx);
         vtx.normal = -normal;
         vtx_builder.AppendVertex(vtx);
         vtx.position = polyline.points[point_i];
         vtx.normal = normal;
         vtx_builder.AppendVertex(vtx);
         vtx.normal = -normal;
         vtx_builder.AppendVertex(vtx);

         if (point_i < contour_end_point_i - 1) {
           compute_normal(point_i + 1);

           // Generate join from the current line to the next line.
           join_proc(vtx_builder, polyline.points[point_i], previous_normal,
                     normal, miter_limit, smoothing);
         }
       }
     }

     // Generate end cap or join.
     if (!polyline.contours[contour_i].is_closed) {
       cap_proc(vtx_builder, polyline.points[contour_end_point_i - 1], normal,
                smoothing);
     } else {
       join_proc(vtx_builder, polyline.points[contour_start_point_i], normal,
                 contour_first_normal, miter_limit, smoothing);
     }
   }

   return vtx_builder.CreateVertexBuffer(buffer);
 }

 bool SolidStrokeContents::Render(const ContentContext& renderer,
                                  const Entity& entity,
                                  RenderPass& pass) const {
   if (stroke_size_ < 0.0) {
     return true;
   }

   using VS = SolidStrokePipeline::VertexShader;
   using FS = SolidStrokePipeline::FragmentShader;

   VS::VertInfo vert_info;
   vert_info.mvp = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
                   entity.GetTransformation();
   Scalar determinant = entity.GetTransformation().GetDeterminant();
   if (determinant == 0) {
     return true;
   }
   Scalar min_size = 1.0f / sqrt(std::abs(determinant));
   vert_info.size = std::max(stroke_size_, min_size);

   FS::FragInfo frag_info;
   frag_info.color = color_.Premultiply();

   Command cmd;
   cmd.primitive_type = PrimitiveType::kTriangleStrip;
   cmd.label = "Solid Stroke";
   auto options = OptionsFromPassAndEntity(pass, entity);
   if (!color_.IsOpaque()) {
     options.stencil_compare = CompareFunction::kEqual;
     options.stencil_operation = StencilOperation::kIncrementClamp;
   }
   cmd.pipeline = renderer.GetSolidStrokePipeline(options);
   cmd.stencil_reference = entity.GetStencilDepth();

   auto smoothing = SmoothingApproximation(
       5.0 / (stroke_size_ * entity.GetTransformation().GetMaxBasisLength()),
       0.0, 0.0);
   cmd.BindVertices(CreateSolidStrokeVertices(path_, pass.GetTransientsBuffer(),
                                              cap_proc_, join_proc_,
                                              miter_limit_, smoothing));
   VS::BindVertInfo(cmd, pass.GetTransientsBuffer().EmplaceUniform(vert_info));
   FS::BindFragInfo(cmd, pass.GetTransientsBuffer().EmplaceUniform(frag_info));

   pass.AddCommand(cmd);

   if (!color_.IsOpaque()) {
     return ClipRestoreContents().Render(renderer, entity, pass);
   }

   return true;
 }

 void SolidStrokeContents::SetStrokeSize(Scalar size) {
   stroke_size_ = size;
 }

 Scalar SolidStrokeContents::GetStrokeSize() const {
   return stroke_size_;
 }

 void SolidStrokeContents::SetStrokeMiter(Scalar miter_limit) {
   if (miter_limit < 0) {
     return;  // Skia behaves like this.
   }
   miter_limit_ = miter_limit;
 }

 Scalar SolidStrokeContents::GetStrokeMiter() {
   return miter_limit_;
 }

 void SolidStrokeContents::SetStrokeCap(Cap cap) {
   cap_ = cap;

   using VS = SolidStrokeVertexShader;
   switch (cap) {
     case Cap::kButt:
       cap_proc_ = [](VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
                      const Point& position, const Point& normal,
                      const SmoothingApproximation& smoothing) {};
       break;
     case Cap::kRound:
       cap_proc_ = [](VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
                      const Point& position, const Point& normal,
                      const SmoothingApproximation& smoothing) {
         SolidStrokeVertexShader::PerVertexData vtx;
         vtx.position = position;
         vtx.pen_down = 1.0;

         Point forward(normal.y, -normal.x);

         auto arc_points =
             CubicPathComponent(
                 normal, normal + forward * PathBuilder::kArcApproximationMagic,
                 forward + normal * PathBuilder::kArcApproximationMagic, forward)
                 .CreatePolyline(smoothing);

         vtx.normal = normal;
         vtx_builder.AppendVertex(vtx);
         vtx.normal = -normal;
         vtx_builder.AppendVertex(vtx);
         for (const auto& point : arc_points) {
           vtx.normal = point;
           vtx_builder.AppendVertex(vtx);
           vtx.normal = (-point).Reflect(forward);
           vtx_builder.AppendVertex(vtx);
         }
       };
       break;
     case Cap::kSquare:
       cap_proc_ = [](VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
                      const Point& position, const Point& normal,
                      const SmoothingApproximation& smoothing) {
         SolidStrokeVertexShader::PerVertexData vtx;
         vtx.position = position;
         vtx.pen_down = 1.0;

         Point forward(normal.y, -normal.x);

         vtx.normal = normal;
         vtx_builder.AppendVertex(vtx);
         vtx.normal = -normal;
         vtx_builder.AppendVertex(vtx);
         vtx.normal = normal + forward;
         vtx_builder.AppendVertex(vtx);
         vtx.normal = -normal + forward;
         vtx_builder.AppendVertex(vtx);
       };
       break;
   }
 }

 SolidStrokeContents::Cap SolidStrokeContents::GetStrokeCap() {
   return cap_;
 }

 static Scalar CreateBevelAndGetDirection(
     VertexBufferBuilder<SolidStrokeVertexShader::PerVertexData>& vtx_builder,
     const Point& position,
     const Point& start_normal,
     const Point& end_normal) {
   SolidStrokeVertexShader::PerVertexData vtx;
   vtx.position = position;
   vtx.pen_down = 1.0;
   vtx.normal = {};
   vtx_builder.AppendVertex(vtx);

   Scalar dir = start_normal.Cross(end_normal) > 0 ? -1 : 1;
   vtx.normal = start_normal * dir;
   vtx_builder.AppendVertex(vtx);
   vtx.normal = end_normal * dir;
   vtx_builder.AppendVertex(vtx);

   return dir;
 }

 void SolidStrokeContents::SetStrokeJoin(Join join) {
   join_ = join;

   using VS = SolidStrokeVertexShader;
   switch (join) {
     case Join::kBevel:
       join_proc_ = [](VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
                       const Point& position, const Point& start_normal,
                       const Point& end_normal, Scalar miter_limit,
                       const SmoothingApproximation& smoothing) {
         CreateBevelAndGetDirection(vtx_builder, position, start_normal,
                                    end_normal);
       };
       break;
     case Join::kMiter:
       join_proc_ = [](VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
                       const Point& position, const Point& start_normal,
                       const Point& end_normal, Scalar miter_limit,
                       const SmoothingApproximation& smoothing) {
         // 1 for no joint (straight line), 0 for max joint (180 degrees).
         Scalar alignment = (start_normal.Dot(end_normal) + 1) / 2;
         if (ScalarNearlyEqual(alignment, 1)) {
           return;
         }

         Scalar dir = CreateBevelAndGetDirection(vtx_builder, position,
                                                 start_normal, end_normal);

         Point miter_point = (start_normal + end_normal) / 2 / alignment;
         if (miter_point.GetDistanceSquared({0, 0}) >
             miter_limit * miter_limit) {
           return;  // Convert to bevel when we exceed the miter limit.
         }

         // Outer miter point.
         SolidStrokeVertexShader::PerVertexData vtx;
         vtx.position = position;
         vtx.pen_down = 1.0;
         vtx.normal = miter_point * dir;
         vtx_builder.AppendVertex(vtx);
       };
       break;
     case Join::kRound:
       join_proc_ = [](VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
                       const Point& position, const Point& start_normal,
                       const Point& end_normal, Scalar miter_limit,
                       const SmoothingApproximation& smoothing) {
         // 0 for no joint (straight line), 1 for max joint (180 degrees).
         Scalar alignment = 1 - (start_normal.Dot(end_normal) + 1) / 2;
         if (ScalarNearlyEqual(alignment, 0)) {
           return;
         }

         Scalar dir = CreateBevelAndGetDirection(vtx_builder, position,
                                                 start_normal, end_normal);

         Point middle = (start_normal + end_normal).Normalize();
         Point middle_handle = middle + Point(-middle.y, middle.x) *
                                            PathBuilder::kArcApproximationMagic *
                                            alignment * dir;
         Point start_handle =
             start_normal + Point(start_normal.y, -start_normal.x) *
                                PathBuilder::kArcApproximationMagic * alignment *
                                dir;

         auto arc_points = CubicPathComponent(start_normal, start_handle,
                                              middle_handle, middle)
                               .CreatePolyline(smoothing);

         SolidStrokeVertexShader::PerVertexData vtx;
         vtx.position = position;
         vtx.pen_down = 1.0;
         for (const auto& point : arc_points) {
           vtx.normal = point * dir;
           vtx_builder.AppendVertex(vtx);
           vtx.normal = (-point * dir).Reflect(middle);
           vtx_builder.AppendVertex(vtx);
         }
       };
       break;
   }
 }

 SolidStrokeContents::Join SolidStrokeContents::GetStrokeJoin() {
   return join_;
 }

 }  // namespace impeller
	// Copyright 2013 The Flutter Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "solid_stroke_contents.h"

	#include <optional>

	#include "impeller/entity/contents/clip_contents.h"
	#include "impeller/entity/contents/content_context.h"
	#include "impeller/entity/entity.h"
	#include "impeller/geometry/path_builder.h"
	#include "impeller/renderer/render_pass.h"

	namespace impeller {

	SolidStrokeContents::SolidStrokeContents() {
	SetStrokeCap(Cap::kButt);
	SetStrokeJoin(Join::kMiter);
	}

	SolidStrokeContents::~SolidStrokeContents() = default;

	void SolidStrokeContents::SetColor(Color color) {
	color_ = color;
	}

	const Color& SolidStrokeContents::GetColor() const {
	return color_;
	}

	void SolidStrokeContents::SetPath(Path path) {
	path_ = std::move(path);
	}

	std::optional<Rect> SolidStrokeContents::GetCoverage(
	const Entity& entity) const {
	if (color_.IsTransparent()) {
	return std::nullopt;
	}

	auto path_bounds = path_.GetBoundingBox();
	if (!path_bounds.has_value()) {
	return std::nullopt;
	}
	auto path_coverage = path_bounds->TransformBounds(entity.GetTransformation());

	Scalar max_radius = 0.5;
	if (cap_ == Cap::kSquare) {
	max_radius = max_radius * kSqrt2;
	}
	if (join_ == Join::kMiter) {
	max_radius = std::max(max_radius, miter_limit_ * 0.5f);
	}
	Scalar determinant = entity.GetTransformation().GetDeterminant();
	if (determinant == 0) {
	return std::nullopt;
	}
	Scalar min_size = 1.0f / sqrt(std::abs(determinant));
	Vector2 max_radius_xy = entity.GetTransformation().TransformDirection(
	Vector2(max_radius, max_radius) * std::max(stroke_size_, min_size));

	return Rect(path_coverage.origin - max_radius_xy,
	Size(path_coverage.size.width + max_radius_xy.x * 2,
	path_coverage.size.height + max_radius_xy.y * 2));
	}

	static VertexBuffer CreateSolidStrokeVertices(
	const Path& path,
	HostBuffer& buffer,
	const SolidStrokeContents::CapProc& cap_proc,
	const SolidStrokeContents::JoinProc& join_proc,
	Scalar miter_limit,
	const SmoothingApproximation& smoothing) {
	using VS = SolidStrokeVertexShader;

	VertexBufferBuilder<VS::PerVertexData> vtx_builder;
	auto polyline = path.CreatePolyline();

	VS::PerVertexData vtx;

	// Normal state.
	Point normal;
	Point previous_normal; // Used for computing joins.

	auto compute_normal = [&polyline, &normal, &previous_normal](size_t point_i) {
	previous_normal = normal;
	Point direction =
	(polyline.points[point_i] - polyline.points[point_i - 1]).Normalize();
	normal = {-direction.y, direction.x};
	};

	for (size_t contour_i = 0; contour_i < polyline.contours.size();
	contour_i++) {
	size_t contour_start_point_i, contour_end_point_i;
	std::tie(contour_start_point_i, contour_end_point_i) =
	polyline.GetContourPointBounds(contour_i);

	switch (contour_end_point_i - contour_start_point_i) {
	case 1: {
	Point p = polyline.points[contour_start_point_i];
	cap_proc(vtx_builder, p, {-1, 0}, smoothing);
	cap_proc(vtx_builder, p, {1, 0}, smoothing);
	continue;
	}
	case 0:
	continue; // This contour has no renderable content.
	default:
	break;
	}

	// The first point's normal is always the same as
	compute_normal(contour_start_point_i + 1);
	const Point contour_first_normal = normal;

	if (contour_i > 0) {
	// This branch only executes when we've just finished drawing a contour
	// and are switching to a new one.
	// We're drawing a triangle strip, so we need to "pick up the pen" by
	// appending transparent vertices between the end of the previous contour
	// and the beginning of the new contour.
	vtx.position = polyline.points[contour_start_point_i - 1];
	vtx.normal = {};
	vtx.pen_down = 0.0;
	// Append two transparent vertices when "picking up" the pen so that the
	// triangle drawn when moving to the beginning of the new contour will
	// have zero volume. This is necessary because strokes with a transparent
	// color affect the stencil buffer to prevent overdraw.
	vtx_builder.AppendVertex(vtx);
	vtx_builder.AppendVertex(vtx);

	vtx.position = polyline.points[contour_start_point_i];
	// Append two vertices at the beginning of the new contour
	// so that the next appended vertex will create a triangle with zero
	// volume.
	vtx_builder.AppendVertex(vtx);
	vtx.pen_down = 1.0;
	vtx_builder.AppendVertex(vtx);
	}

	// Generate start cap.
	if (!polyline.contours[contour_i].is_closed) {
	cap_proc(vtx_builder, polyline.points[contour_start_point_i], -normal,
	smoothing);
	}

	// Generate contour geometry.
	for (size_t point_i = contour_start_point_i; point_i < contour_end_point_i;
	point_i++) {
	if (point_i > contour_start_point_i) {
	// Generate line rect.
	vtx.position = polyline.points[point_i - 1];
	vtx.pen_down = 1.0;
	vtx.normal = normal;
	vtx_builder.AppendVertex(vtx);
	vtx.normal = -normal;
	vtx_builder.AppendVertex(vtx);
	vtx.position = polyline.points[point_i];
	vtx.normal = normal;
	vtx_builder.AppendVertex(vtx);
	vtx.normal = -normal;
	vtx_builder.AppendVertex(vtx);

	if (point_i < contour_end_point_i - 1) {
	compute_normal(point_i + 1);

	// Generate join from the current line to the next line.
	join_proc(vtx_builder, polyline.points[point_i], previous_normal,
	normal, miter_limit, smoothing);
	}
	}
	}

	// Generate end cap or join.
	if (!polyline.contours[contour_i].is_closed) {
	cap_proc(vtx_builder, polyline.points[contour_end_point_i - 1], normal,
	smoothing);
	} else {
	join_proc(vtx_builder, polyline.points[contour_start_point_i], normal,
	contour_first_normal, miter_limit, smoothing);
	}
	}

	return vtx_builder.CreateVertexBuffer(buffer);
	}

	bool SolidStrokeContents::Render(const ContentContext& renderer,
	const Entity& entity,
	RenderPass& pass) const {
	if (stroke_size_ < 0.0) {
	return true;
	}

	using VS = SolidStrokePipeline::VertexShader;
	using FS = SolidStrokePipeline::FragmentShader;

	VS::VertInfo vert_info;
	vert_info.mvp = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
	entity.GetTransformation();
	Scalar determinant = entity.GetTransformation().GetDeterminant();
	if (determinant == 0) {
	return true;
	}
	Scalar min_size = 1.0f / sqrt(std::abs(determinant));
	vert_info.size = std::max(stroke_size_, min_size);

	FS::FragInfo frag_info;
	frag_info.color = color_.Premultiply();

	Command cmd;
	cmd.primitive_type = PrimitiveType::kTriangleStrip;
	cmd.label = "Solid Stroke";
	auto options = OptionsFromPassAndEntity(pass, entity);
	if (!color_.IsOpaque()) {
	options.stencil_compare = CompareFunction::kEqual;
	options.stencil_operation = StencilOperation::kIncrementClamp;
	}
	cmd.pipeline = renderer.GetSolidStrokePipeline(options);
	cmd.stencil_reference = entity.GetStencilDepth();

	auto smoothing = SmoothingApproximation(
	5.0 / (stroke_size_ * entity.GetTransformation().GetMaxBasisLength()),
	0.0, 0.0);
	cmd.BindVertices(CreateSolidStrokeVertices(path_, pass.GetTransientsBuffer(),
	cap_proc_, join_proc_,
	miter_limit_, smoothing));
	VS::BindVertInfo(cmd, pass.GetTransientsBuffer().EmplaceUniform(vert_info));
	FS::BindFragInfo(cmd, pass.GetTransientsBuffer().EmplaceUniform(frag_info));

	pass.AddCommand(cmd);

	if (!color_.IsOpaque()) {
	return ClipRestoreContents().Render(renderer, entity, pass);
	}

	return true;
	}

	void SolidStrokeContents::SetStrokeSize(Scalar size) {
	stroke_size_ = size;
	}

	Scalar SolidStrokeContents::GetStrokeSize() const {
	return stroke_size_;
	}

	void SolidStrokeContents::SetStrokeMiter(Scalar miter_limit) {
	if (miter_limit < 0) {
	return; // Skia behaves like this.
	}
	miter_limit_ = miter_limit;
	}

	Scalar SolidStrokeContents::GetStrokeMiter() {
	return miter_limit_;
	}

	void SolidStrokeContents::SetStrokeCap(Cap cap) {
	cap_ = cap;

	using VS = SolidStrokeVertexShader;
	switch (cap) {
	case Cap::kButt:
	cap_proc_ = [](VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
	const Point& position, const Point& normal,
	const SmoothingApproximation& smoothing) {};
	break;
	case Cap::kRound:
	cap_proc_ = [](VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
	const Point& position, const Point& normal,
	const SmoothingApproximation& smoothing) {
	SolidStrokeVertexShader::PerVertexData vtx;
	vtx.position = position;
	vtx.pen_down = 1.0;

	Point forward(normal.y, -normal.x);

	auto arc_points =
	CubicPathComponent(
	normal, normal + forward * PathBuilder::kArcApproximationMagic,
	forward + normal * PathBuilder::kArcApproximationMagic, forward)
	.CreatePolyline(smoothing);

	vtx.normal = normal;
	vtx_builder.AppendVertex(vtx);
	vtx.normal = -normal;
	vtx_builder.AppendVertex(vtx);
	for (const auto& point : arc_points) {
	vtx.normal = point;
	vtx_builder.AppendVertex(vtx);
	vtx.normal = (-point).Reflect(forward);
	vtx_builder.AppendVertex(vtx);
	}
	};
	break;
	case Cap::kSquare:
	cap_proc_ = [](VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
	const Point& position, const Point& normal,
	const SmoothingApproximation& smoothing) {
	SolidStrokeVertexShader::PerVertexData vtx;
	vtx.position = position;
	vtx.pen_down = 1.0;

	Point forward(normal.y, -normal.x);

	vtx.normal = normal;
	vtx_builder.AppendVertex(vtx);
	vtx.normal = -normal;
	vtx_builder.AppendVertex(vtx);
	vtx.normal = normal + forward;
	vtx_builder.AppendVertex(vtx);
	vtx.normal = -normal + forward;
	vtx_builder.AppendVertex(vtx);
	};
	break;
	}
	}

	SolidStrokeContents::Cap SolidStrokeContents::GetStrokeCap() {
	return cap_;
	}

	static Scalar CreateBevelAndGetDirection(
	VertexBufferBuilder<SolidStrokeVertexShader::PerVertexData>& vtx_builder,
	const Point& position,
	const Point& start_normal,
	const Point& end_normal) {
	SolidStrokeVertexShader::PerVertexData vtx;
	vtx.position = position;
	vtx.pen_down = 1.0;
	vtx.normal = {};
	vtx_builder.AppendVertex(vtx);

	Scalar dir = start_normal.Cross(end_normal) > 0 ? -1 : 1;
	vtx.normal = start_normal * dir;
	vtx_builder.AppendVertex(vtx);
	vtx.normal = end_normal * dir;
	vtx_builder.AppendVertex(vtx);

	return dir;
	}

	void SolidStrokeContents::SetStrokeJoin(Join join) {
	join_ = join;

	using VS = SolidStrokeVertexShader;
	switch (join) {
	case Join::kBevel:
	join_proc_ = [](VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
	const Point& position, const Point& start_normal,
	const Point& end_normal, Scalar miter_limit,
	const SmoothingApproximation& smoothing) {
	CreateBevelAndGetDirection(vtx_builder, position, start_normal,
	end_normal);
	};
	break;
	case Join::kMiter:
	join_proc_ = [](VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
	const Point& position, const Point& start_normal,
	const Point& end_normal, Scalar miter_limit,
	const SmoothingApproximation& smoothing) {
	// 1 for no joint (straight line), 0 for max joint (180 degrees).
	Scalar alignment = (start_normal.Dot(end_normal) + 1) / 2;
	if (ScalarNearlyEqual(alignment, 1)) {
	return;
	}

	Scalar dir = CreateBevelAndGetDirection(vtx_builder, position,
	start_normal, end_normal);

	Point miter_point = (start_normal + end_normal) / 2 / alignment;
	if (miter_point.GetDistanceSquared({0, 0}) >
	miter_limit * miter_limit) {
	return; // Convert to bevel when we exceed the miter limit.
	}

	// Outer miter point.
	SolidStrokeVertexShader::PerVertexData vtx;
	vtx.position = position;
	vtx.pen_down = 1.0;
	vtx.normal = miter_point * dir;
	vtx_builder.AppendVertex(vtx);
	};
	break;
	case Join::kRound:
	join_proc_ = [](VertexBufferBuilder<VS::PerVertexData>& vtx_builder,
	const Point& position, const Point& start_normal,
	const Point& end_normal, Scalar miter_limit,
	const SmoothingApproximation& smoothing) {
	// 0 for no joint (straight line), 1 for max joint (180 degrees).
	Scalar alignment = 1 - (start_normal.Dot(end_normal) + 1) / 2;
	if (ScalarNearlyEqual(alignment, 0)) {
	return;
	}

	Scalar dir = CreateBevelAndGetDirection(vtx_builder, position,
	start_normal, end_normal);

	Point middle = (start_normal + end_normal).Normalize();
	Point middle_handle = middle + Point(-middle.y, middle.x) *
	PathBuilder::kArcApproximationMagic *
	alignment * dir;
	Point start_handle =
	start_normal + Point(start_normal.y, -start_normal.x) *
	PathBuilder::kArcApproximationMagic * alignment *
	dir;

	auto arc_points = CubicPathComponent(start_normal, start_handle,
	middle_handle, middle)
	.CreatePolyline(smoothing);

	SolidStrokeVertexShader::PerVertexData vtx;
	vtx.position = position;
	vtx.pen_down = 1.0;
	for (const auto& point : arc_points) {
	vtx.normal = point * dir;
	vtx_builder.AppendVertex(vtx);
	vtx.normal = (-point * dir).Reflect(middle);
	vtx_builder.AppendVertex(vtx);
	}
	};
	break;
	}
	}

	SolidStrokeContents::Join SolidStrokeContents::GetStrokeJoin() {
	return join_;
	}

	} // namespace impeller