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, bool requires_readback)
	ExperimentalCanvas (ContentContext &renderer, RenderTarget &render_target, bool requires_readback, Rect cull_rect)
	ExperimentalCanvas (ContentContext &renderer, RenderTarget &render_target, bool requires_readback, 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, bool can_distribute_opacity) 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 ()
virtual void	Save (uint32_t total_content_depth=kMaxDepth)
virtual void	SaveLayer (const Paint &paint, std::optional< Rect > bounds=std::nullopt, const std::shared_ptr< ImageFilter > &backdrop_filter=nullptr, ContentBoundsPromise bounds_promise=ContentBoundsPromise::kUnknown, uint32_t total_content_depth=kMaxDepth, bool can_distribute_opacity=false)
virtual bool	Restore ()
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)
virtual void	DrawTextFrame (const std::shared_ptr< TextFrame > &text_frame, Point position, const Paint &paint)
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 ()

Additional Inherited Members
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

This Canvas attempts to translate from display lists to draw calls directly.

It's not fully implemented yet but if successful it will be replacing the aiks Canvas functionality.

See also:

• go/impeller-canvas-efficiency

Definition at line 28 of file experimental_canvas.h.

Constructor & Destructor Documentation

ExperimentalCanvas() [1/3]

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

Definition at line 110 of file experimental_canvas.cc.

    : Canvas(),
      renderer_(renderer),
      render_target_(render_target),
      requires_readback_(requires_readback),
      clip_coverage_stack_(EntityPassClipStack(
          Rect::MakeSize(render_target.GetRenderTargetSize()))) {
  SetupRenderPass();
}

ExperimentalCanvas() [2/3]

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

Definition at line 122 of file experimental_canvas.cc.

    : Canvas(cull_rect),
      renderer_(renderer),
      render_target_(render_target),
      requires_readback_(requires_readback),
      clip_coverage_stack_(EntityPassClipStack(
          Rect::MakeSize(render_target.GetRenderTargetSize()))) {
  SetupRenderPass();
}

ExperimentalCanvas() [3/3]

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

Definition at line 135 of file experimental_canvas.cc.

    : Canvas(cull_rect),
      renderer_(renderer),
      render_target_(render_target),
      requires_readback_(requires_readback),
      clip_coverage_stack_(EntityPassClipStack(
          Rect::MakeSize(render_target.GetRenderTargetSize()))) {
  SetupRenderPass();
}

~ExperimentalCanvas()

impeller::ExperimentalCanvas::~ExperimentalCanvas ( )

overridedefault

Member Function Documentation

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 381 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->SetForceTextColor(paint.mask_blur_descriptor.has_value());
  text_contents->SetScale(GetCurrentTransform().GetMaxBasisLengthXY());
  text_contents->SetColor(paint.color);
  text_contents->SetOffset(position);
  text_contents->SetTextProperties(paint.color,                           //
                                   paint.style == Paint::Style::kStroke,  //
                                   paint.stroke_width,                    //
                                   paint.stroke_cap,                      //
                                   paint.stroke_join,                     //
                                   paint.stroke_miter                     //
  );
 
  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, GetCurrentTransform())));
 
  AddRenderEntityToCurrentPass(std::move(entity), false);
}

EndReplay()

void impeller::ExperimentalCanvas::EndReplay

(

)

Definition at line 553 of file experimental_canvas.cc.

                                   {
  FML_DCHECK(inline_pass_contexts_.size() == 1u);
  inline_pass_contexts_.back()->EndPass();
 
  // If requires_readback_ was true, then we rendered to an offscreen texture
  // instead of to the onscreen provided in the render target. Now we need to
  // draw or blit the offscreen back to the onscreen.
  if (requires_readback_) {
    BlitToOnscreen();
  }
 
  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 265 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::kSubpassAppendSnapshotTransform ||
      transform_stack_.back().rendering_mode ==
          Entity::RenderingMode::kSubpassPrependSnapshotTransform) {
    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());
    clip_coverage_stack_.PopSubpass();
    transform_stack_.pop_back();
 
    // We don't need to restore clips if a saveLayer was performed, as the clip
    // state is per render target, and no more rendering operations will be
    // performed as the render target workloaded is completed in the restore.
    return true;
  }
 
  size_t num_clips = transform_stack_.back().num_clips;
  transform_stack_.pop_back();
 
  if (num_clips > 0) {
    Entity entity;
    entity.SetTransform(
        Matrix::MakeTranslation(Vector3(-GetGlobalPassPosition())) *
        GetCurrentTransform());
    // This path is empty because ClipRestoreContents just generates a quad that
    // takes up the full render target.
    auto clip_restore = std::make_shared<ClipRestoreContents>();
    clip_restore->SetRestoreHeight(GetClipHeight());
    entity.SetContents(std::move(clip_restore));
 
    auto current_clip_coverage = clip_coverage_stack_.CurrentClipCoverage();
    if (current_clip_coverage.has_value()) {
      // Entity transforms are relative to the current pass position, so we need
      // to check clip coverage in the same space.
      current_clip_coverage =
          current_clip_coverage->Shift(-GetGlobalPassPosition());
    }
 
    auto clip_coverage = entity.GetClipCoverage(current_clip_coverage);
    if (clip_coverage.coverage.has_value()) {
      clip_coverage.coverage =
          clip_coverage.coverage->Shift(GetGlobalPassPosition());
    }
 
    EntityPassClipStack::ClipStateResult clip_state_result =
        clip_coverage_stack_.ApplyClipState(clip_coverage, entity,
                                            GetClipHeightFloor(),
                                            GetGlobalPassPosition());
 
    if (clip_state_result.clip_did_change) {
      // We only need to update the pass scissor if the clip state has changed.
      SetClipScissor(clip_coverage_stack_.CurrentClipCoverage(),
                     *render_passes_.back(), GetGlobalPassPosition());
    }
 
    if (!clip_state_result.should_render) {
      return true;
    }
 
    entity.Render(renderer_, *render_passes_.back());
  }
 
  return true;
}

Save()

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

overridevirtual

Reimplemented from impeller::Canvas.

Definition at line 192 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;
  entry.distributed_opacity = transform_stack_.back().distributed_opacity;
  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, bool  can_distribute_opacity  )

overridevirtual

Reimplemented from impeller::Canvas.

Definition at line 206 of file experimental_canvas.cc.

                                 {
  if (can_distribute_opacity && !backdrop_filter &&
      Paint::CanApplyOpacityPeephole(paint)) {
    Save(total_content_depth);
    transform_stack_.back().distributed_opacity *= paint.color.alpha;
    return;
  }
  // 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());
  }
 
  // When applying a save layer, absorb any pending distributed opacity.
  Paint paint_copy = paint;
  paint_copy.color.alpha *= transform_stack_.back().distributed_opacity;
  transform_stack_.back().distributed_opacity = 1.0;
 
  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_copy, 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::kSubpassAppendSnapshotTransform;
  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);
 
  // Start non-collapsed subpasses with a fresh clip coverage stack limited by
  // the subpass coverage. This is important because image filters applied to
  // save layers may transform the subpass texture after it's rendered,
  // causing parent clip coverage to get misaligned with the actual area that
  // the subpass will affect in the parent pass.
  clip_coverage_stack_.PushSubpass(subpass_coverage, GetClipHeight());
}

---

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

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