impeller::LineContents Class Reference

#include <line_contents.h>

Inheritance diagram for impeller::LineContents:

Classes
struct	EffectiveLineParameters

Public Member Functions
bool	Render (const ContentContext &renderer, const Entity &entity, RenderPass &pass) const override
std::optional< Rect >	GetCoverage (const Entity &entity) const override
	Get the area of the render pass that will be affected when this contents is rendered.
Public Member Functions inherited from impeller::Contents
	Contents ()
virtual	~Contents ()
void	SetCoverageHint (std::optional< Rect > coverage_hint)
	Hint that specifies the coverage area of this Contents that will actually be used during rendering. This is for optimization purposes only and can not be relied on as a clip. May optionally affect the result of GetCoverage().
const std::optional< Rect > &	GetCoverageHint () const
virtual bool	IsOpaque (const Matrix &transform) const
	Whether this Contents only emits opaque source colors from the fragment stage. This value does not account for any entity properties (e.g. the blend mode), clips/visibility culling, or inherited opacity.
virtual std::optional< Snapshot >	RenderToSnapshot (const ContentContext &renderer, const Entity &entity, const SnapshotOptions &options) const
	Render this contents to a snapshot, respecting the entity's transform, path, clip depth, and blend mode. The result texture size is always the size of GetCoverage(entity).
std::optional< Size >	GetColorSourceSize () const
	Return the color source's intrinsic size, if available.
void	SetColorSourceSize (Size size)
virtual void	SetInheritedOpacity (Scalar opacity)
	Inherit the provided opacity.
virtual std::optional< Color >	AsBackgroundColor (const Entity &entity, ISize target_size) const
	Returns a color if this Contents will flood the given target_size with a color. This output color is the "Source" color that will be used for the Entity's blend operation.
virtual bool	ApplyColorFilter (const ColorFilterProc &color_filter_proc)
	If possible, applies a color filter to this contents inputs on the CPU.

Static Public Member Functions
static std::vector< uint8_t >	CreateCurveData (Scalar width, Scalar radius, Scalar scale)
static fml::StatusOr< EffectiveLineParameters >	CalculatePerVertex (LineVertexShader::PerVertexData *per_vertex, const LineGeometry *geometry, const Matrix &entity_transform)
static std::unique_ptr< LineContents >	Make (std::unique_ptr< LineGeometry > geometry, Color color)
Static Public Member Functions inherited from impeller::Contents
static std::shared_ptr< Contents >	MakeAnonymous (RenderProc render_proc, CoverageProc coverage_proc)

Static Public Attributes
static const Scalar	kSampleRadius = 1.f

Additional Inherited Members
Public Types inherited from impeller::Contents
using	ColorFilterProc = std::function< Color(Color)>
using	RenderProc = std::function< bool(const ContentContext &renderer, const Entity &entity, RenderPass &pass)>
using	CoverageProc = std::function< std::optional< Rect >(const Entity &entity)>

Detailed Description

Definition at line 15 of file line_contents.h.

Member Function Documentation

CalculatePerVertex()

fml::StatusOr< LineContents::EffectiveLineParameters > impeller::LineContents::CalculatePerVertex ( LineVertexShader::PerVertexData *  per_vertex, const LineGeometry *  geometry, const Matrix &  entity_transform  )

static

Calculates the values needed for the vertex shader, per vertex. Returns the effective line parameters that are used. These differ from the ones provided by geometry when the line gets clamped for being too thin.

Definition at line 227 of file line_contents.cc.

                                                                 {
  Scalar scale = entity_transform.GetMaxBasisLengthXY();
 
  // Transform the line into unrotated space by rotating p1 to be horizontal
  // with p0. We do this because there seems to be a flaw in the eN calculations
  // where they create thinner lines for diagonal lines.
  Point diff = geometry->GetP1() - geometry->GetP0();
  Scalar magnitude = diff.GetLength();
  Point p1_prime = Point(geometry->GetP0().x + magnitude, geometry->GetP0().y);
 
  std::array<Point, 4> corners;
  // Make sure we get kSampleRadius pixels to sample from.
  Scalar expand_size = std::max(kSampleRadius / scale, kSampleRadius);
  if (!LineGeometry::ComputeCorners(
          corners.data(), entity_transform,
          /*extend_endpoints=*/geometry->GetCap() != Cap::kButt,
          geometry->GetP0(), p1_prime, geometry->GetWidth())) {
    return fml::Status(fml::StatusCode::kAborted, "No valid corners");
  }
  Scalar effective_line_width = std::fabsf((corners[2] - corners[0]).y);
  ExpandLine(corners, Point(expand_size, expand_size));
  Scalar padded_line_width = std::fabsf((corners[2] - corners[0]).y);
  Scalar effective_sample_radius =
      (padded_line_width - effective_line_width) / 2.f;
  LineInfo line_info =
      CalculateLineInfo(geometry->GetP0(), p1_prime, effective_line_width,
                        effective_sample_radius);
  for (auto& corner : corners) {
    *per_vertex++ = {
        .position = corner,
        .e0 = line_info.e0,
        .e1 = line_info.e1,
        .e2 = line_info.e2,
        .e3 = line_info.e3,
    };
  }
 
  return EffectiveLineParameters{.width = effective_line_width,
                                 .radius = effective_sample_radius};
}

References impeller::LineGeometry::ComputeCorners(), impeller::LineGeometry::GetCap(), impeller::TPoint< T >::GetLength(), impeller::Matrix::GetMaxBasisLengthXY(), impeller::LineGeometry::GetP0(), impeller::LineGeometry::GetP1(), impeller::LineGeometry::GetWidth(), fml::kAborted, impeller::kButt, kSampleRadius, impeller::LineContents::EffectiveLineParameters::width, impeller::TPoint< T >::x, impeller::TPoint< T >::y, and y.

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

CreateCurveData()

std::vector< uint8_t > impeller::LineContents::CreateCurveData ( Scalar  width, Scalar  radius, Scalar  scale  )

static

Definition at line 197 of file line_contents.cc.

                                                                 {
  std::vector<uint8_t> curve_data;
  curve_data.reserve(kCurveResolution);
  // More simply written as rise / run:
  // double slope = 1.0 / ((radius * 2) / (scale * width + radius));
  double slope = (scale * width + radius) / (radius * 2);
  slope = std::max(slope, 1.0);
  for (int i = 0; i < kCurveResolution; ++i) {
    double norm =
        (static_cast<double>(i)) / static_cast<double>(kCurveResolution - 1);
    double scaled = slope * norm;
    curve_data.push_back(DoubleToUint8(scaled));
  }
  return curve_data;
}

References i, and width.

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

GetCoverage()

std::optional< Rect > impeller::LineContents::GetCoverage ( const Entity &  entity ) const

overridevirtual

Get the area of the render pass that will be affected when this contents is rendered.

During rendering, coverage coordinates count pixels from the top left corner of the framebuffer.

Returns

The coverage rectangle. An std::nullopt result means that rendering this contents has no effect on the output color.

Implements impeller::Contents.

Definition at line 193 of file line_contents.cc.

                                                                      {
  return geometry_->GetCoverage(entity.GetTransform());
}

References impeller::Entity::GetTransform().

Make()

std::unique_ptr< LineContents > impeller::LineContents::Make ( std::unique_ptr< LineGeometry >  geometry, Color  color  )

static

Definition at line 135 of file line_contents.cc.

                 {
  return std::unique_ptr<LineContents>(
      new LineContents(std::move(geometry), color));
}

Referenced by impeller::Canvas::DrawLine(), and impeller::testing::TEST().

Render()

bool impeller::LineContents::Render ( const ContentContext &  renderer, const Entity &  entity, RenderPass &  pass  ) const

overridevirtual

Implements impeller::Contents.

Definition at line 145 of file line_contents.cc.

                                                  {
  auto& data_host_buffer = renderer.GetTransientsDataBuffer();
 
  VS::FrameInfo frame_info;
  FS::FragInfo frag_info;
  frag_info.color = color_;
  frag_info.cap_type = (geometry_->GetCap() == Cap::kRound) ? 1.0f : 0.0f;
 
  Scalar scale = entity.GetTransform().GetMaxBasisLengthXY();
 
  auto geometry_result =
      CreateGeometry(renderer, entity, pass, geometry_.get());
 
  std::shared_ptr<Texture> curve_texture = CreateCurveTexture(
      geometry_->GetWidth(), kSampleRadius, scale, renderer.GetContext());
 
  SamplerDescriptor sampler_desc;
  sampler_desc.min_filter = MinMagFilter::kLinear;
  sampler_desc.mag_filter = MinMagFilter::kLinear;
 
  FS::BindCurve(
      pass, curve_texture,
      renderer.GetContext()->GetSamplerLibrary()->GetSampler(sampler_desc));
 
  PipelineBuilderCallback pipeline_callback =
      [&renderer](ContentContextOptions options) {
        return renderer.GetLinePipeline(options);
      };
 
  return ColorSourceContents::DrawGeometry<VS>(
      this, geometry_.get(), renderer, entity, pass, pipeline_callback,
      frame_info,
      /*bind_fragment_callback=*/
      [&frag_info, &data_host_buffer](RenderPass& pass) {
        FS::BindFragInfo(pass, data_host_buffer.EmplaceUniform(frag_info));
        pass.SetCommandLabel("Line");
        return true;
      },
      /*force_stencil=*/false,
      /*create_geom_callback=*/
      [geometry_result = std::move(geometry_result)](
          const ContentContext& renderer, const Entity& entity,
          RenderPass& pass,
          const Geometry* geometry) { return geometry_result.second; });
}

References impeller::ContentContext::GetContext(), impeller::ContentContext::GetLinePipeline(), impeller::Matrix::GetMaxBasisLengthXY(), impeller::Entity::GetTransform(), impeller::ContentContext::GetTransientsDataBuffer(), impeller::kLinear, impeller::kRound, kSampleRadius, impeller::SamplerDescriptor::mag_filter, and impeller::SamplerDescriptor::min_filter.

Member Data Documentation

kSampleRadius

const Scalar impeller::LineContents::kSampleRadius = 1.f

static

Definition at line 17 of file line_contents.h.

Referenced by CalculatePerVertex(), Render(), impeller::testing::TEST(), and impeller::testing::TEST().

---

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

• impeller/entity/contents/line_contents.h
• impeller/entity/contents/line_contents.cc