impeller::ExperimentalCanvas Class Reference

#include <experimental_canvas.h>

Inheritance diagram for impeller::ExperimentalCanvas:

Classes
struct	SaveLayerState

Public Member Functions
	ExperimentalCanvas (ContentContext &renderer, RenderTarget &render_target)
	ExperimentalCanvas (ContentContext &renderer, RenderTarget &render_target, Rect cull_rect)
	ExperimentalCanvas (ContentContext &renderer, RenderTarget &render_target, IRect cull_rect)
	~ExperimentalCanvas () override=default
void	Save (uint32_t total_content_depth) override
void	SaveLayer (const Paint &paint, std::optional< Rect > bounds, const std::shared_ptr< ImageFilter > &backdrop_filter, ContentBoundsPromise bounds_promise, uint32_t total_content_depth) override
bool	Restore () override
void	EndReplay ()
void	DrawTextFrame (const std::shared_ptr< TextFrame > &text_frame, Point position, const Paint &paint) override
Public Member Functions inherited from impeller::Canvas
	Canvas ()
	Canvas (Rect cull_rect)
	Canvas (IRect cull_rect)
virtual	~Canvas ()
size_t	GetSaveCount () const
void	RestoreToCount (size_t count)
const Matrix &	GetCurrentTransform () const
const std::optional< Rect >	GetCurrentLocalCullingBounds () const
void	ResetTransform ()
void	Transform (const Matrix &transform)
void	Concat (const Matrix &transform)
void	PreConcat (const Matrix &transform)
void	Translate (const Vector3 &offset)
void	Scale (const Vector2 &scale)
void	Scale (const Vector3 &scale)
void	Skew (Scalar sx, Scalar sy)
void	Rotate (Radians radians)
void	DrawPath (const Path &path, const Paint &paint)
void	DrawPaint (const Paint &paint)
void	DrawLine (const Point &p0, const Point &p1, const Paint &paint)
void	DrawRect (const Rect &rect, const Paint &paint)
void	DrawOval (const Rect &rect, const Paint &paint)
void	DrawRRect (const Rect &rect, const Size &corner_radii, const Paint &paint)
void	DrawCircle (const Point &center, Scalar radius, const Paint &paint)
void	DrawPoints (std::vector< Point > points, Scalar radius, const Paint &paint, PointStyle point_style)
void	DrawImage (const std::shared_ptr< Image > &image, Point offset, const Paint &paint, SamplerDescriptor sampler={})
void	DrawImageRect (const std::shared_ptr< Image > &image, Rect source, Rect dest, const Paint &paint, SamplerDescriptor sampler={}, SourceRectConstraint src_rect_constraint=SourceRectConstraint::kFast)
void	ClipPath (const Path &path, Entity::ClipOperation clip_op=Entity::ClipOperation::kIntersect)
void	ClipRect (const Rect &rect, Entity::ClipOperation clip_op=Entity::ClipOperation::kIntersect)
void	ClipOval (const Rect &bounds, Entity::ClipOperation clip_op=Entity::ClipOperation::kIntersect)
void	ClipRRect (const Rect &rect, const Size &corner_radii, Entity::ClipOperation clip_op=Entity::ClipOperation::kIntersect)
void	DrawVertices (const std::shared_ptr< VerticesGeometry > &vertices, BlendMode blend_mode, const Paint &paint)
void	DrawAtlas (const std::shared_ptr< Image > &atlas, std::vector< Matrix > transforms, std::vector< Rect > texture_coordinates, std::vector< Color > colors, BlendMode blend_mode, SamplerDescriptor sampler, std::optional< Rect > cull_rect, const Paint &paint)
Picture	EndRecordingAsPicture ()

Private Member Functions
void	AddRenderEntityToCurrentPass (Entity entity, bool reuse_depth) override
void	AddClipEntityToCurrentPass (Entity entity) override

Additional Inherited Members
Public Attributes inherited from impeller::Canvas
struct impeller::Canvas::DebugOptions	debug_options
Static Public Attributes inherited from impeller::Canvas
static constexpr uint32_t	kMaxDepth = 1 << 24
Protected Member Functions inherited from impeller::Canvas
size_t	GetClipHeight () const
void	Initialize (std::optional< Rect > cull_rect)
void	Reset ()
Protected Attributes inherited from impeller::Canvas
std::deque< CanvasStackEntry >	transform_stack_
std::optional< Rect >	initial_cull_rect_
uint64_t	current_depth_ = 0u

Detailed Description

Definition at line 20 of file experimental_canvas.h.

Constructor & Destructor Documentation

ExperimentalCanvas() [1/3]

impeller::ExperimentalCanvas::ExperimentalCanvas	(	ContentContext &	renderer,
		RenderTarget &	render_target
	)

Definition at line 88 of file experimental_canvas.cc.

    : Canvas(), renderer_(renderer), render_target_(render_target) {
  SetupRenderPass();
}

ExperimentalCanvas() [2/3]

impeller::ExperimentalCanvas::ExperimentalCanvas	(	ContentContext &	renderer,
		RenderTarget &	render_target,
		Rect	cull_rect
	)

Definition at line 94 of file experimental_canvas.cc.

    : Canvas(cull_rect), renderer_(renderer), render_target_(render_target) {
  SetupRenderPass();
}

ExperimentalCanvas() [3/3]

impeller::ExperimentalCanvas::ExperimentalCanvas	(	ContentContext &	renderer,
		RenderTarget &	render_target,
		IRect	cull_rect
	)

Definition at line 101 of file experimental_canvas.cc.

    : Canvas(cull_rect), renderer_(renderer), render_target_(render_target) {
  SetupRenderPass();
}

~ExperimentalCanvas()

impeller::ExperimentalCanvas::~ExperimentalCanvas ( )

overridedefault

Member Function Documentation

AddClipEntityToCurrentPass()

void impeller::ExperimentalCanvas::AddClipEntityToCurrentPass ( Entity  entity )

overrideprivatevirtual

Reimplemented from impeller::Canvas.

Definition at line 313 of file experimental_canvas.cc.

                                                                 {
  auto transform = entity.GetTransform();
  entity.SetTransform(
      Matrix::MakeTranslation(Vector3(-GetGlobalPassPosition())) * transform);
  // Ideally the clip depth would be greater than the current rendering
  // depth because any rendering calls that follow this clip operation will
  // pre-increment the depth and then be rendering above our clip depth,
  // but that case will be caught by the CHECK in AddRenderEntity above.
  // In practice we sometimes have a clip set with no rendering after it
  // and in such cases the current depth will equal the clip depth.
  // Eventually the DisplayList should optimize these out, but it is hard
  // to know if a clip will actually be used in advance of storing it in
  // the DisplayList buffer.
  // See https://github.com/flutter/flutter/issues/147021
  FML_CHECK(current_depth_ <= transform_stack_.back().clip_depth)
      << current_depth_ << " <=? " << transform_stack_.back().clip_depth;
  entity.SetClipDepth(transform_stack_.back().clip_depth);
  entity.Render(renderer_, *render_passes_.back());
}

AddRenderEntityToCurrentPass()

void impeller::ExperimentalCanvas::AddRenderEntityToCurrentPass ( Entity  entity, bool  reuse_depth  )

overrideprivatevirtual

Reimplemented from impeller::Canvas.

Definition at line 286 of file experimental_canvas.cc.

                                                                        {
  auto transform = entity.GetTransform();
  entity.SetTransform(
      Matrix::MakeTranslation(Vector3(-GetGlobalPassPosition())) * transform);
  if (!reuse_depth) {
    ++current_depth_;
  }
  // We can render at a depth up to and including the depth of the currently
  // active clips and we will still be clipped out, but we cannot render at
  // a depth that is greater than the current clips or we will not be clipped.
  FML_CHECK(current_depth_ <= transform_stack_.back().clip_depth)
      << current_depth_ << " <=? " << transform_stack_.back().clip_depth;
  entity.SetClipDepth(current_depth_);
 
  if (entity.GetBlendMode() > Entity::kLastPipelineBlendMode) {
    if (renderer_.GetDeviceCapabilities().SupportsFramebufferFetch()) {
      ApplyFramebufferBlend(entity);
    } else {
      VALIDATION_LOG << "Emulated advanced blends are currently unsupported.";
      return;
    }
  }
 
  entity.Render(renderer_, *render_passes_.back());
}

DrawTextFrame()

void impeller::ExperimentalCanvas::DrawTextFrame ( const std::shared_ptr< TextFrame > &  text_frame, Point  position, const Paint &  paint  )

overridevirtual

Reimplemented from impeller::Canvas.

Definition at line 257 of file experimental_canvas.cc.

                        {
  Entity entity;
  entity.SetClipDepth(GetClipHeight());
  entity.SetBlendMode(paint.blend_mode);
 
  auto text_contents = std::make_shared<TextContents>();
  text_contents->SetTextFrame(text_frame);
  text_contents->SetColor(paint.color);
  text_contents->SetForceTextColor(paint.mask_blur_descriptor.has_value());
  text_contents->SetScale(GetCurrentTransform().GetMaxBasisLengthXY());
 
  entity.SetTransform(GetCurrentTransform() *
                      Matrix::MakeTranslation(position));
 
  // TODO(bdero): This mask blur application is a hack. It will always wind up
  //              doing a gaussian blur that affects the color source itself
  //              instead of just the mask. The color filter text support
  //              needs to be reworked in order to interact correctly with
  //              mask filters.
  //              https://github.com/flutter/flutter/issues/133297
  entity.SetContents(
      paint.WithFilters(paint.WithMaskBlur(std::move(text_contents), true)));
 
  AddRenderEntityToCurrentPass(std::move(entity), false);
}

EndReplay()

void impeller::ExperimentalCanvas::EndReplay ( )

inline

Definition at line 44 of file experimental_canvas.h.

                   {
    FML_DCHECK(inline_pass_contexts_.size() == 1u);
    inline_pass_contexts_.back()->EndPass();
    render_passes_.clear();
    inline_pass_contexts_.clear();
    renderer_.GetRenderTargetCache()->End();
 
    Reset();
    Initialize(initial_cull_rect_);
  }

Restore()

bool impeller::ExperimentalCanvas::Restore ( )

overridevirtual

Reimplemented from impeller::Canvas.

Definition at line 194 of file experimental_canvas.cc.

                                 {
  FML_DCHECK(transform_stack_.size() > 0);
  if (transform_stack_.size() == 1) {
    return false;
  }
 
  // This check is important to make sure we didn't exceed the depth
  // that the clips were rendered at while rendering any of the
  // rendering ops. It is OK for the current depth to equal the
  // outgoing clip depth because that means the clipping would have
  // been successful up through the last rendering op, but it cannot
  // be greater.
  // Also, we bump the current rendering depth to the outgoing clip
  // depth so that future rendering operations are not clipped by
  // any of the pixels set by the expiring clips. It is OK for the
  // estimates used to determine the clip depth in save/saveLayer
  // to be overly conservative, but we need to jump the depth to
  // the clip depth so that the next rendering op will get a
  // larger depth (it will pre-increment the current_depth_ value).
  FML_CHECK(current_depth_ <= transform_stack_.back().clip_depth)
      << current_depth_ << " <=? " << transform_stack_.back().clip_depth;
  current_depth_ = transform_stack_.back().clip_depth;
 
  if (transform_stack_.back().rendering_mode ==
      Entity::RenderingMode::kSubpass) {
    auto inline_pass = std::move(inline_pass_contexts_.back());
 
    SaveLayerState save_layer_state = save_layer_state_.back();
    save_layer_state_.pop_back();
 
    std::shared_ptr<Contents> contents =
        PaintPassDelegate(save_layer_state.paint)
            .CreateContentsForSubpassTarget(inline_pass->GetTexture(),
                                            transform_stack_.back().transform);
 
    inline_pass->EndPass();
    render_passes_.pop_back();
    inline_pass_contexts_.pop_back();
 
    Entity element_entity;
    element_entity.SetClipDepth(++current_depth_);
    element_entity.SetContents(std::move(contents));
    element_entity.SetBlendMode(save_layer_state.paint.blend_mode);
    element_entity.SetTransform(Matrix::MakeTranslation(
        Vector3(save_layer_state.coverage.GetOrigin())));
 
    if (element_entity.GetBlendMode() > Entity::kLastPipelineBlendMode) {
      if (renderer_.GetDeviceCapabilities().SupportsFramebufferFetch()) {
        ApplyFramebufferBlend(element_entity);
      } else {
        VALIDATION_LOG << "Emulated advanced blends are currently unsupported.";
        element_entity.SetBlendMode(BlendMode::kSourceOver);
      }
    }
 
    element_entity.Render(renderer_, *render_passes_.back());
  }
 
  transform_stack_.pop_back();
 
  return true;
}

Save()

void impeller::ExperimentalCanvas::Save ( uint32_t  total_content_depth )

overridevirtual

Reimplemented from impeller::Canvas.

Definition at line 142 of file experimental_canvas.cc.

                                                          {
  auto entry = CanvasStackEntry{};
  entry.transform = transform_stack_.back().transform;
  entry.cull_rect = transform_stack_.back().cull_rect;
  entry.clip_depth = current_depth_ + total_content_depth;
  FML_CHECK(entry.clip_depth <= transform_stack_.back().clip_depth)
      << entry.clip_depth << " <=? " << transform_stack_.back().clip_depth
      << " after allocating " << total_content_depth;
  entry.clip_height = transform_stack_.back().clip_height;
  entry.rendering_mode = Entity::RenderingMode::kDirect;
  transform_stack_.emplace_back(entry);
}

SaveLayer()

void impeller::ExperimentalCanvas::SaveLayer ( const Paint &  paint, std::optional< Rect >  bounds, const std::shared_ptr< ImageFilter > &  backdrop_filter, ContentBoundsPromise  bounds_promise, uint32_t  total_content_depth  )

overridevirtual

Reimplemented from impeller::Canvas.

Definition at line 155 of file experimental_canvas.cc.

                                  {
  // Can we always guarantee that we get a bounds? Does a lack of bounds
  // indicate something?
  if (!bounds.has_value()) {
    bounds = Rect::MakeSize(render_target_.GetRenderTargetSize());
  }
  Rect subpass_coverage = bounds->TransformBounds(GetCurrentTransform());
  auto target =
      CreateRenderTarget(renderer_,
                         ISize::MakeWH(subpass_coverage.GetSize().width,
                                       subpass_coverage.GetSize().height),
                         1u, Color::BlackTransparent());
  entity_pass_targets_.push_back(std::move(target));
  save_layer_state_.push_back(SaveLayerState{paint, subpass_coverage});
 
  CanvasStackEntry entry;
  entry.transform = transform_stack_.back().transform;
  entry.cull_rect = transform_stack_.back().cull_rect;
  entry.clip_depth = current_depth_ + total_content_depth;
  FML_CHECK(entry.clip_depth <= transform_stack_.back().clip_depth)
      << entry.clip_depth << " <=? " << transform_stack_.back().clip_depth
      << " after allocating " << total_content_depth;
  entry.clip_height = transform_stack_.back().clip_height;
  entry.rendering_mode = Entity::RenderingMode::kSubpass;
  transform_stack_.emplace_back(entry);
 
  auto inline_pass = std::make_unique<InlinePassContext>(
      renderer_, *entity_pass_targets_.back(), 0);
  inline_pass_contexts_.emplace_back(std::move(inline_pass));
 
  auto result = inline_pass_contexts_.back()->GetRenderPass(0u);
  render_passes_.push_back(result.pass);
}

---

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

• impeller/aiks/experimental_canvas.h
• impeller/aiks/experimental_canvas.cc