impeller::UberSDFGeometry Class Reference

Geometry for rendering shapes using the UberSDF shader. More...

#include <uber_sdf_geometry.h>

Inheritance diagram for impeller::UberSDFGeometry:

Public Member Functions
	UberSDFGeometry (const UberSDFParameters &params)
	~UberSDFGeometry () override
GeometryResult	GetPositionBuffer (const ContentContext &renderer, const Entity &entity, RenderPass &pass) const override
std::optional< Rect >	GetCoverage (const Matrix &transform) const override
	The coverage rectangle of this geometry, transformed by the transform argument.
bool	CoversArea (const Matrix &transform, const IRect &rect) const override
	Determines if this geometry, transformed by the given transform, will completely cover all of the pixels within the given integer rect.
bool	IsAxisAlignedRect () const override
Public Member Functions inherited from impeller::Geometry
virtual	~Geometry ()
virtual GeometryResult::Mode	GetResultMode () 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

Geometry for rendering shapes using the UberSDF shader.

Definition at line 14 of file uber_sdf_geometry.h.

Constructor & Destructor Documentation

UberSDFGeometry()

impeller::UberSDFGeometry::UberSDFGeometry ( const UberSDFParameters &  params )

explicit

Definition at line 11 of file uber_sdf_geometry.cc.

    : params_(params) {}

~UberSDFGeometry()

impeller::UberSDFGeometry::~UberSDFGeometry ( )

overridedefault

Member Function Documentation

CoversArea()

bool impeller::UberSDFGeometry::CoversArea ( const Matrix &  transform, const IRect &  rect  ) const

overridevirtual

Determines if this geometry, transformed by the given transform, will completely cover all of the pixels within the given integer rect.

The integer rect, by definition, will contain all of the area covered by any pixel within its boundary.

The return value can be a conservative estimate which will still be useful for certain optimizations. It may return false for obscure cases that might actually contain all of the pixels if it is too computationally costly to prove containment, but it should never return 'true' unless the implementation can prove that all pixels are fully covered (rendered) by the geometry.

Returns

true if the transformed geometry is guaranteed to cover the given rect. May return false in some cases where the transformed geometry does in fact cover the rect.

Reimplemented from impeller::Geometry.

Definition at line 35 of file uber_sdf_geometry.cc.

                                                          {
  if (params_.type == UberSDFParameters::Type::kRect && !params_.stroke &&
      transform.IsTranslationScaleOnly()) {
    // The SDF is a filled axis-aligned rectangle. It "covers" the input rect if
    // the SDF shader fully replaces the pixels contained in the rect parameter.
    // The SDF shader is computed by the GPU at the center of the pixels it
    // intersects and it computes a coverage for the pixels that reaches full
    // coverage (1.0) at (aa_pixels / 2.0) inside the geometry. That coverage
    // value will be applied for every MSAA sample intersected by the geometry.
    //
    // Since the input rect is an integer rect we already know that it encloses
    // at least half a pixel on each side of the pixel centers inside it and
    // that it encloses every MSAA sample location within those pixels. This
    // means that the integer rect already meets all of the above criteria (as
    // long as kAntialiasPixels is <= 1.0), so if the transformed geometry
    // contains the integer input rect, all pixels will be fully rendered.
    static_assert(UberSDFParameters::kAntialiasPixels <= 1.0);
    return Rect::MakeEllipseBounds(params_.center, params_.size)
        .TransformBounds(transform)
        .Contains(rect);
  }
 
  // Conservatively return false. We can optimize to handle more cases in the
  // future if needed for performance reasons.
  return false;
}

References impeller::UberSDFParameters::center, impeller::TRect< T >::Contains(), impeller::UberSDFParameters::kAntialiasPixels, impeller::UberSDFParameters::kRect, impeller::TRect< Scalar >::MakeEllipseBounds(), impeller::UberSDFParameters::size, impeller::UberSDFParameters::stroke, transform, impeller::TRect< T >::TransformBounds(), and impeller::UberSDFParameters::type.

GetCoverage()

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

overridevirtual

The coverage rectangle of this geometry, transformed by the transform argument.

Implements impeller::Geometry.

Definition at line 30 of file uber_sdf_geometry.cc.

                                   {
  return GetExpandedBounds(transform).TransformAndClipBounds(transform);
}

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

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

GetPositionBuffer()

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

overridevirtual

Implements impeller::Geometry.

Definition at line 16 of file uber_sdf_geometry.cc.

                            {
  // Return a quad (FillRectGeometry) that covers the base shape expanded by
  // padding for stroke width and AA.
  //
  // For future performance enhancements (if the fill rate is a limiting factor)
  // this can be optimized to use a tighter geometry for specific shapes. E.g.
  // Using a tighter polygon, or cutting out the interior for stroked shapes.
  FillRectGeometry frg(GetExpandedBounds(entity.GetTransform()));
  return frg.GetPositionBuffer(renderer, entity, pass);
}

References impeller::FillRectGeometry::GetPositionBuffer(), and impeller::Entity::GetTransform().

IsAxisAlignedRect()

bool impeller::UberSDFGeometry::IsAxisAlignedRect ( ) const

overridevirtual

Reimplemented from impeller::Geometry.

Definition at line 63 of file uber_sdf_geometry.cc.

                                              {
  return (params_.type == UberSDFParameters::Type::kRect && !params_.stroke);
}

References impeller::UberSDFParameters::kRect, impeller::UberSDFParameters::stroke, and impeller::UberSDFParameters::type.

---

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

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