impeller::StrokeRectGeometry Class Reference

#include <rect_geometry.h>

Inheritance diagram for impeller::StrokeRectGeometry:

Public Member Functions
	StrokeRectGeometry (const Rect &rect, const StrokeParameters &stroke)
	~StrokeRectGeometry () override
GeometryResult	GetPositionBuffer (const ContentContext &renderer, const Entity &entity, RenderPass &pass) const override
std::optional< Rect >	GetCoverage (const Matrix &transform) const override
Public Member Functions inherited from impeller::Geometry
virtual	~Geometry ()
virtual GeometryResult::Mode	GetResultMode () const
virtual bool	CoversArea (const Matrix &transform, const Rect &rect) const
	Determines if this geometry, transformed by the given transform, will completely cover all surface area of the given rect.
virtual bool	IsAxisAlignedRect () const
virtual bool	CanApplyMaskFilter () const
virtual Scalar	ComputeAlphaCoverage (const Matrix &transform) const

Additional Inherited Members
Static Public Member Functions inherited from impeller::Geometry
static std::unique_ptr< Geometry >	MakeFillPath (const flutter::DlPath &path, std::optional< Rect > inner_rect=std::nullopt)
static std::unique_ptr< Geometry >	MakeStrokePath (const flutter::DlPath &path, const StrokeParameters &stroke={})
static std::unique_ptr< Geometry >	MakeCover ()
static std::unique_ptr< Geometry >	MakeRect (const Rect &rect)
static std::unique_ptr< Geometry >	MakeOval (const Rect &rect)
static std::unique_ptr< Geometry >	MakeLine (const Point &p0, const Point &p1, const StrokeParameters &stroke)
static std::unique_ptr< Geometry >	MakeCircle (const Point &center, Scalar radius)
static std::unique_ptr< Geometry >	MakeStrokedCircle (const Point &center, Scalar radius, Scalar stroke_width)
static std::unique_ptr< Geometry >	MakeFilledArc (const Rect &oval_bounds, Degrees start, Degrees sweep, bool include_center)
static std::unique_ptr< Geometry >	MakeStrokedArc (const Rect &oval_bounds, Degrees start, Degrees sweep, const StrokeParameters &stroke)
static std::unique_ptr< Geometry >	MakeRoundRect (const Rect &rect, const Size &radii)
static std::unique_ptr< Geometry >	MakeRoundSuperellipse (const Rect &rect, Scalar corner_radius)
static Scalar	ComputeStrokeAlphaCoverage (const Matrix &entity, Scalar stroke_width)
	Compute an alpha value to simulate lower coverage of fractional pixel strokes.
static GeometryResult	ComputePositionGeometry (const ContentContext &renderer, const Tessellator::VertexGenerator &generator, const Entity &entity, RenderPass &pass)

Detailed Description

Definition at line 37 of file rect_geometry.h.

Constructor & Destructor Documentation

StrokeRectGeometry()

impeller::StrokeRectGeometry::StrokeRectGeometry ( const Rect &  rect, const StrokeParameters &  stroke  )

explicit

Definition at line 50 of file rect_geometry.cc.

    : rect_(rect),
      stroke_width_(stroke.width),
      stroke_join_(AdjustStrokeJoin(stroke)) {}

~StrokeRectGeometry()

impeller::StrokeRectGeometry::~StrokeRectGeometry ( )

overridedefault

Member Function Documentation

GetCoverage()

std::optional< Rect > impeller::StrokeRectGeometry::GetCoverage ( const Matrix &  transform ) const

overridevirtual

Implements impeller::Geometry.

Definition at line 337 of file rect_geometry.cc.

                                   {
  return rect_.TransformBounds(transform);
}

References transform, and impeller::TRect< T >::TransformBounds().

GetPositionBuffer()

GeometryResult impeller::StrokeRectGeometry::GetPositionBuffer ( const ContentContext &  renderer, const Entity &  entity, RenderPass &  pass  ) const

overridevirtual

Implements impeller::Geometry.

Definition at line 58 of file rect_geometry.cc.

                            {
  if (stroke_width_ < 0.0) {
    return {};
  }
  Scalar max_basis = entity.GetTransform().GetMaxBasisLengthXY();
  if (max_basis == 0) {
    return {};
  }
 
  Scalar min_size = kMinStrokeSize / max_basis;
  Scalar stroke_width = std::max(stroke_width_, min_size);
  Scalar half_stroke_width = stroke_width * 0.5f;
 
  auto& data_host_buffer = renderer.GetTransientsDataBuffer();
  const Rect& rect = rect_;
  bool interior_filled = (stroke_width >= rect.GetSize().MinDimension());
 
  switch (stroke_join_) {
    case Join::kRound: {
      Tessellator::Trigs trigs =
          renderer.GetTessellator().GetTrigsForDeviceRadius(half_stroke_width *
                                                            max_basis);
 
      FML_DCHECK(trigs.size() >= 2u);
 
      auto vertex_count = trigs.size() * 4;
      if (!interior_filled) {
        // If there is a hole in the interior (as with most stroked rects
        // unless the stroke width is really really wide) then we need
        // to perform some surgery to generate the hollowed-out interior.
        vertex_count += 12;
      }
 
      return GeometryResult{
          .type = PrimitiveType::kTriangleStrip,
          .vertex_buffer =
              {
                  .vertex_buffer = data_host_buffer.Emplace(
                      vertex_count * sizeof(Point), alignof(Point),
                      [hsw = half_stroke_width, &rect, vertex_count, &trigs,
                       interior_filled](uint8_t* buffer) {
                        Scalar left = rect.GetLeft();
                        Scalar top = rect.GetTop();
                        Scalar right = rect.GetRight();
                        Scalar bottom = rect.GetBottom();
 
                        auto vertices = reinterpret_cast<Point*>(buffer);
                        [[maybe_unused]]
                        auto vertices_end = vertices + vertex_count;
 
                        // Traverse top down, left to right across slices.
 
                        // Slice 1: Draw across between top pair of round joins.
                        for (auto trig : trigs) {
                          // trig.sin goes from 0 to 1
                          // trig.cos goes from 1 to 0
                          *vertices++ = Point(left - trig.sin * hsw,
                                              top - trig.cos * hsw);
                          *vertices++ = Point(right + trig.sin * hsw,
                                              top - trig.cos * hsw);
                        }
                        // Ends up with vertices that draw across the bottom
                        // of the top curved section (left - hsw, top) to
                        // (right + hsw, top). This is the starting pair of
                        // vertices for the following square section.
 
                        if (interior_filled) {
                          // If interior is filled, we can just let the bottom
                          // pair of vertices of the top edge connect to the
                          // top pair of vertices of the bottom edge generated
                          // in slice 5 below. They both go left-right so they
                          // will create a proper zig-zag box to connect the
                          // 2 sections.
                        } else {
                          // Slice 2: Draw the inner part of the top stroke.
                          // Simply extend down from the last horizontal pair
                          // of vertices to (top + hsw).
                          *vertices++ = Point(left - hsw, top + hsw);
                          *vertices++ = Point(right + hsw, top + hsw);
 
                          // Slice 3: Draw the left and right edges.
 
                          // Slice 3a: Draw the right edge first.
                          // Since we are already at the right edge from the
                          // previous slice, we just have to add 2 vertices
                          // to get to the bottom of that right edge, but we
                          // have to start with an additional vertex that
                          // connects to (right - hsw) instead of the left
                          // side of the rectangle to avoid a big triangle
                          // through the hollow interior section.
                          *vertices++ = Point(right - hsw, top + hsw);
                          *vertices++ = Point(right + hsw, bottom - hsw);
                          *vertices++ = Point(right - hsw, bottom - hsw);
 
                          // Now we need to jump up for the left edge, but we
                          // need to dupliate the last point and the next point
                          // to avoid drawing anything connecting them. These
                          // 2 vertices end up generating 2 empty triangles.
                          *vertices++ = Point(right - hsw, bottom - hsw);
                          *vertices++ = Point(left + hsw, top + hsw);
 
                          // Slice 3b: Now draw the left edge.
                          // We draw this in a specific zig zag order so that
                          // we end up at (left - hsw, bottom - hsw) to connect
                          // properly to the next section.
                          *vertices++ = Point(left + hsw, top + hsw);
                          *vertices++ = Point(left - hsw, top + hsw);
                          *vertices++ = Point(left + hsw, bottom - hsw);
                          *vertices++ = Point(left - hsw, bottom - hsw);
 
                          // Slice 4: Draw the inner part of the bottom stroke.
                          // Since the next section starts by drawing across
                          // the width of the rect at Y=bottom, we simple have
                          // to make sure that we presently have a pair of
                          // vertices that span the top of that section. The
                          // last point was (left - hsw, bottom - hsw), so we
                          // just have to add its right side partner which
                          // is not the same as the vertex before that. This
                          // extra vertex ends up defining an empty triangle,
                          // but sets us up for the final slice to complete
                          // this interior part of the bottom stroke.
                          *vertices++ = Point(right + hsw, bottom - hsw);
                          // Now the first pair of vertices below will
                          // "complete the zig-zag box" for the inner part
                          // of the bottom stroke.
                        }
 
                        // Slice 5: Draw between bottom pair of round joins.
                        for (auto trig : trigs) {
                          // trig.sin goes from 0 to 1
                          // trig.cos goes from 1 to 0
                          *vertices++ = Point(left - trig.cos * hsw,
                                              bottom + trig.sin * hsw);
                          *vertices++ = Point(right + trig.cos * hsw,
                                              bottom + trig.sin * hsw);
                        }
 
                        // Make sure our estimate is always up to date.
                        FML_DCHECK(vertices == vertices_end);
                      }),
                  .vertex_count = vertex_count,
                  .index_type = IndexType::kNone,
              },
          .transform = entity.GetShaderTransform(pass),
          .mode = GeometryResult::Mode::kNormal,
      };
    }
 
    case Join::kBevel: {
      if (interior_filled) {
        return GeometryResult{
            .type = PrimitiveType::kTriangleStrip,
            .vertex_buffer =
                {
                    .vertex_buffer = data_host_buffer.Emplace(
                        8 * sizeof(Point), alignof(Point),
                        [hsw = half_stroke_width, &rect](uint8_t* buffer) {
                          Scalar left = rect.GetLeft();
                          Scalar top = rect.GetTop();
                          Scalar right = rect.GetRight();
                          Scalar bottom = rect.GetBottom();
                          auto vertices = reinterpret_cast<Point*>(buffer);
                          vertices[0] = Point(left, top - hsw);
                          vertices[1] = Point(right, top - hsw);
                          vertices[2] = Point(left - hsw, top);
                          vertices[3] = Point(right + hsw, top);
                          vertices[4] = Point(left - hsw, bottom);
                          vertices[5] = Point(right + hsw, bottom);
                          vertices[6] = Point(left, bottom + hsw);
                          vertices[7] = Point(right, bottom + hsw);
                        }),
                    .vertex_count = 8u,
                    .index_type = IndexType::kNone,
                },
            .transform = entity.GetShaderTransform(pass),
            .mode = GeometryResult::Mode::kNormal,
        };
      }
      return GeometryResult{
          .type = PrimitiveType::kTriangleStrip,
          .vertex_buffer =
              {
                  .vertex_buffer = data_host_buffer.Emplace(
                      17 * sizeof(Point), alignof(Point),
                      [hsw = half_stroke_width, &rect](uint8_t* buffer) {
                        Scalar left = rect.GetLeft();
                        Scalar top = rect.GetTop();
                        Scalar right = rect.GetRight();
                        Scalar bottom = rect.GetBottom();
                        auto vertices = reinterpret_cast<Point*>(buffer);
                        vertices[0] = Point(left - hsw, top);
                        vertices[1] = Point(left + hsw, top + hsw);
                        vertices[2] = Point(left, top - hsw);
                        vertices[3] = Point(right - hsw, top + hsw);
                        vertices[4] = Point(right, top - hsw);
                        vertices[5] = Point(right - hsw, top + hsw);
                        vertices[6] = Point(right + hsw, top);
                        vertices[7] = Point(right - hsw, bottom - hsw);
                        vertices[8] = Point(right + hsw, bottom);
                        vertices[9] = Point(right - hsw, bottom - hsw);
                        vertices[10] = Point(right, bottom + hsw);
                        vertices[11] = Point(left + hsw, bottom - hsw);
                        vertices[12] = Point(left, bottom + hsw);
                        vertices[13] = Point(left + hsw, bottom - hsw);
                        vertices[14] = Point(left - hsw, bottom);
                        vertices[15] = Point(left + hsw, top + hsw);
                        vertices[16] = Point(left - hsw, top);
                      }),
                  .vertex_count = 17u,
                  .index_type = IndexType::kNone,
              },
          .transform = entity.GetShaderTransform(pass),
          .mode = GeometryResult::Mode::kNormal,
      };
    }
 
    case Join::kMiter: {
      if (interior_filled) {
        return GeometryResult{
            .type = PrimitiveType::kTriangleStrip,
            .vertex_buffer =
                {
                    .vertex_buffer = data_host_buffer.Emplace(
                        4 * sizeof(Point), alignof(Point),
                        [hsw = half_stroke_width, &rect](uint8_t* buffer) {
                          Scalar left = rect.GetLeft();
                          Scalar top = rect.GetTop();
                          Scalar right = rect.GetRight();
                          Scalar bottom = rect.GetBottom();
                          auto vertices = reinterpret_cast<Point*>(buffer);
 
                          vertices[0] = Point(left - hsw, top - hsw);
                          vertices[1] = Point(right + hsw, top - hsw);
                          vertices[2] = Point(left - hsw, bottom + hsw);
                          vertices[3] = Point(right + hsw, bottom + hsw);
                        }),
                    .vertex_count = 4u,
                    .index_type = IndexType::kNone,
                },
            .transform = entity.GetShaderTransform(pass),
            .mode = GeometryResult::Mode::kNormal,
        };
      }
      return GeometryResult{
          .type = PrimitiveType::kTriangleStrip,
          .vertex_buffer =
              {
                  .vertex_buffer = data_host_buffer.Emplace(
                      10 * sizeof(Point), alignof(Point),
                      [hsw = half_stroke_width, &rect](uint8_t* buffer) {
                        Scalar left = rect.GetLeft();
                        Scalar top = rect.GetTop();
                        Scalar right = rect.GetRight();
                        Scalar bottom = rect.GetBottom();
                        auto vertices = reinterpret_cast<Point*>(buffer);
                        vertices[0] = Point(left - hsw, top - hsw);
                        vertices[1] = Point(left + hsw, top + hsw);
                        vertices[2] = Point(right + hsw, top - hsw);
                        vertices[3] = Point(right - hsw, top + hsw);
                        vertices[4] = Point(right + hsw, bottom + hsw);
                        vertices[5] = Point(right - hsw, bottom - hsw);
                        vertices[6] = Point(left - hsw, bottom + hsw);
                        vertices[7] = Point(left + hsw, bottom - hsw);
                        vertices[8] = Point(left - hsw, top - hsw);
                        vertices[9] = Point(left + hsw, top + hsw);
                      }),
                  .vertex_count = 10u,
                  .index_type = IndexType::kNone,
              },
          .transform = entity.GetShaderTransform(pass),
          .mode = GeometryResult::Mode::kNormal,
      };
    }
  }
}

References FML_DCHECK, impeller::TRect< T >::GetBottom(), impeller::TRect< T >::GetLeft(), impeller::Matrix::GetMaxBasisLengthXY(), impeller::TRect< T >::GetRight(), impeller::Entity::GetShaderTransform(), impeller::TRect< T >::GetSize(), impeller::ContentContext::GetTessellator(), impeller::TRect< T >::GetTop(), impeller::Entity::GetTransform(), impeller::ContentContext::GetTransientsDataBuffer(), impeller::Tessellator::GetTrigsForDeviceRadius(), impeller::kBevel, impeller::kMinStrokeSize, impeller::kMiter, impeller::kNone, impeller::GeometryResult::kNormal, impeller::kRound, impeller::kTriangleStrip, impeller::Tessellator::Trigs::size(), and impeller::GeometryResult::type.

---

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

• impeller/entity/geometry/rect_geometry.h
• impeller/entity/geometry/rect_geometry.cc