#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 ()

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 ()

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.

Constructor & Destructor Documentation

◆ ExperimentalCanvas() [1/3]

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

Definition at line 109 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 121 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 134 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 558 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);
 }

References impeller::Canvas::GetClipHeight(), impeller::Canvas::GetCurrentTransform(), impeller::Paint::kStroke, impeller::Matrix::MakeTranslation(), paint, impeller::Entity::SetBlendMode(), impeller::Entity::SetClipDepth(), impeller::Entity::SetContents(), and impeller::Entity::SetTransform().

◆ EndReplay()

void impeller::ExperimentalCanvas::EndReplay ( )

Definition at line 745 of file experimental_canvas.cc.

                                    {
   FML_DCHECK(render_passes_.size() == 1u);
   render_passes_.back().inline_pass_context->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();
   renderer_.GetRenderTargetCache()->End();
  
   Reset();
   Initialize(initial_cull_rect_);
 }

References impeller::ContentContext::GetRenderTargetCache(), impeller::Canvas::initial_cull_rect_, impeller::Canvas::Initialize(), and impeller::Canvas::Reset().

Referenced by impeller::ExperimentalDlDispatcher::FinishRecording().

◆ Restore()

bool impeller::ExperimentalCanvas::Restore ( )

overridevirtual

Reimplemented from impeller::Canvas.

Definition at line 416 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 lazy_render_pass = std::move(render_passes_.back());
     render_passes_.pop_back();
     // Force the render pass to be constructed if it never was.
     lazy_render_pass.inline_pass_context->GetRenderPass(0);
  
     SaveLayerState save_layer_state = save_layer_state_.back();
     save_layer_state_.pop_back();
  
     std::shared_ptr<Contents> contents =
         PaintPassDelegate(save_layer_state.paint)
             .CreateContentsForSubpassTarget(
                 lazy_render_pass.inline_pass_context->GetTexture(),
                 transform_stack_.back().transform);
  
     lazy_render_pass.inline_pass_context->EndPass();
  
     // Round the subpass texture position for pixel alignment with the parent
     // pass render target. By default, we draw subpass textures with nearest
     // sampling, so aligning here is important for avoiding visual nearest
     // sampling errors caused by limited floating point precision when
     // straddling a half pixel boundary.
     //
     // We do this in lieu of expanding/rounding out the subpass coverage in
     // order to keep the bounds wrapping consistently tight around subpass
     // elements. Which is necessary to avoid intense flickering in cases
     // where a subpass texture has a large blur filter with clamp sampling.
     //
     // See also this bug: https://github.com/flutter/flutter/issues/144213
     Point subpass_texture_position =
         (save_layer_state.coverage.GetOrigin() - GetGlobalPassPosition())
             .Round();
  
     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(subpass_texture_position)));
  
     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().inline_pass_context->GetRenderPass(0).pass  //
     );
     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().inline_pass_context->GetRenderPass(0).pass,  //
           GetGlobalPassPosition()                                             //
       );
     }
  
     if (!clip_state_result.should_render) {
       return true;
     }
  
     entity.Render(
         renderer_,
         *render_passes_.back().inline_pass_context->GetRenderPass(0).pass);
   }
  
   return true;
 }

References impeller::EntityPassClipStack::ApplyClipState(), impeller::Paint::blend_mode, impeller::EntityPassClipStack::ClipStateResult::clip_did_change, impeller::Contents::ClipCoverage::coverage, impeller::ExperimentalCanvas::SaveLayerState::coverage, impeller::PaintPassDelegate::CreateContentsForSubpassTarget(), impeller::Canvas::current_depth_, impeller::EntityPassClipStack::CurrentClipCoverage(), impeller::Entity::GetBlendMode(), impeller::Entity::GetClipCoverage(), impeller::Canvas::GetClipHeight(), impeller::Canvas::GetCurrentTransform(), impeller::ContentContext::GetDeviceCapabilities(), impeller::TRect< T >::GetOrigin(), impeller::Entity::kLastPipelineBlendMode, impeller::kSourceOver, impeller::Entity::kSubpassAppendSnapshotTransform, impeller::Entity::kSubpassPrependSnapshotTransform, impeller::Matrix::MakeTranslation(), impeller::ExperimentalCanvas::SaveLayerState::paint, impeller::EntityPassClipStack::PopSubpass(), impeller::Entity::Render(), impeller::Entity::SetBlendMode(), impeller::Entity::SetClipDepth(), impeller::SetClipScissor(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), impeller::EntityPassClipStack::ClipStateResult::should_render, impeller::Capabilities::SupportsFramebufferFetch(), impeller::Canvas::transform_stack_, and VALIDATION_LOG.

◆ Save()

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

overridevirtual

Reimplemented from impeller::Canvas.

Definition at line 193 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);
 }

References impeller::Canvas::current_depth_, impeller::Entity::kDirect, impeller::CanvasStackEntry::transform, and impeller::Canvas::transform_stack_.

Referenced by SaveLayer().

◆ 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 207 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());
   }
  
   // SaveLayer is a no-op, depending on the bounds promise. Should/Can DL elide
   // this?
   if (bounds->IsEmpty()) {
     Save(total_content_depth);
     return;
   }
  
   // The maximum coverage of the subpass. Subpasses textures should never
   // extend outside the parent pass texture or the current clip coverage.
   Rect coverage_limit = Rect::MakeOriginSize(
       GetGlobalPassPosition(),
       Size(render_passes_.back().inline_pass_context->GetTexture()->GetSize()));
  
   // BDF No-op. need to do some precomputation to ensure this is fully skipped.
   if (backdrop_filter) {
     if (!clip_coverage_stack_.HasCoverage()) {
       Save(total_content_depth);
       return;
     }
     auto maybe_clip_coverage = clip_coverage_stack_.CurrentClipCoverage();
     if (!maybe_clip_coverage.has_value()) {
       Save(total_content_depth);
       return;
     }
     auto clip_coverage = maybe_clip_coverage.value();
     if (clip_coverage.IsEmpty() ||
         !coverage_limit.IntersectsWithRect(clip_coverage)) {
       Save(total_content_depth);
       return;
     }
   }
  
   if (can_distribute_opacity && !backdrop_filter &&
       Paint::CanApplyOpacityPeephole(paint)) {
     Save(total_content_depth);
     transform_stack_.back().distributed_opacity *= paint.color.alpha;
     return;
   }
  
   // Backdrop filter state, ignored if there is no BDF.
   std::shared_ptr<FilterContents> backdrop_filter_contents;
   Point local_position = {0, 0};
   if (backdrop_filter) {
     auto current_clip_coverage = clip_coverage_stack_.CurrentClipCoverage();
     if (current_clip_coverage.has_value()) {
       local_position =
           current_clip_coverage->GetOrigin() - GetGlobalPassPosition();
     }
     EntityPass::BackdropFilterProc backdrop_filter_proc =
         [backdrop_filter = backdrop_filter->Clone()](
             const FilterInput::Ref& input, const Matrix& effect_transform,
             Entity::RenderingMode rendering_mode) {
           auto filter = backdrop_filter->WrapInput(input);
           filter->SetEffectTransform(effect_transform);
           filter->SetRenderingMode(rendering_mode);
           return filter;
         };
  
     auto rendering_config = std::move(render_passes_.back());
     render_passes_.pop_back();
  
     // If the very first thing we render in this EntityPass is a subpass that
     // happens to have a backdrop filter, than that backdrop filter will end
     // may wind up sampling from the raw, uncleared texture that came straight
     // out of the texture cache. By calling `pass_context.GetRenderPass` here,
     // we force the texture to pass through at least one RenderPass with the
     // correct clear configuration before any sampling occurs.
     rendering_config.inline_pass_context->GetRenderPass(0);
  
     ISize restore_size =
         rendering_config.inline_pass_context->GetTexture()->GetSize();
  
     std::shared_ptr<Texture> input_texture =
         rendering_config.entity_pass_target->Flip(
             *renderer_.GetContext()->GetResourceAllocator());
  
     backdrop_filter_contents = backdrop_filter_proc(
         FilterInput::Make(std::move(input_texture)),
         transform_stack_.back().transform.Basis(),
         // When the subpass has a translation that means the math with
         // the snapshot has to be different.
         transform_stack_.back().transform.HasTranslation()
             ? Entity::RenderingMode::kSubpassPrependSnapshotTransform
             : Entity::RenderingMode::kSubpassAppendSnapshotTransform);
  
     // The subpass will need to read from the current pass texture when
     // rendering the backdrop, so if there's an active pass, end it prior to
     // rendering the subpass.
     rendering_config.inline_pass_context->EndPass();
  
     // Create a new render pass that the backdrop filter contents will be
     // restored to in order to continue rendering.
     render_passes_.push_back(LazyRenderingConfig(
         renderer_, std::move(rendering_config.entity_pass_target)));
     // Eagerly restore the BDF contents.
  
     // If the pass context returns a backdrop texture, we need to draw it to the
     // current pass. We do this because it's faster and takes significantly less
     // memory than storing/loading large MSAA textures. Also, it's not possible
     // to blit the non-MSAA resolve texture of the previous pass to MSAA
     // textures (let alone a transient one).
     Rect size_rect = Rect::MakeSize(restore_size);
     auto msaa_backdrop_contents = TextureContents::MakeRect(size_rect);
     msaa_backdrop_contents->SetStencilEnabled(false);
     msaa_backdrop_contents->SetLabel("MSAA backdrop");
     msaa_backdrop_contents->SetSourceRect(size_rect);
     msaa_backdrop_contents->SetTexture(
         rendering_config.inline_pass_context->GetTexture());
  
     Entity msaa_backdrop_entity;
     msaa_backdrop_entity.SetContents(std::move(msaa_backdrop_contents));
     msaa_backdrop_entity.SetBlendMode(BlendMode::kSource);
     msaa_backdrop_entity.SetClipDepth(std::numeric_limits<uint32_t>::max());
     if (!msaa_backdrop_entity.Render(renderer_,
                                      *render_passes_.back()
                                           .inline_pass_context->GetRenderPass(0)
                                           .pass)) {
       VALIDATION_LOG << "Failed to render MSAA backdrop filter entity.";
       return;
     }
  
     // Restore any clips that were recorded before the backdrop filter was
     // applied.
     auto& replay_entities = clip_coverage_stack_.GetReplayEntities();
     for (const auto& replay : replay_entities) {
       SetClipScissor(
           clip_coverage_stack_.CurrentClipCoverage(),
           *render_passes_.back().inline_pass_context->GetRenderPass(0).pass,
           GetGlobalPassPosition());
       if (!replay.entity.Render(renderer_,
                                 *render_passes_.back()
                                      .inline_pass_context->GetRenderPass(0)
                                      .pass)) {
         VALIDATION_LOG << "Failed to render entity for clip restore.";
       }
     }
   }
  
   // 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;
  
   // Backdrop Filter must expand bounds to at least the clip stack, otherwise
   // the coverage of the parent render pass.
   Rect subpass_coverage = bounds->TransformBounds(GetCurrentTransform());
   if (backdrop_filter_contents) {
     FML_CHECK(clip_coverage_stack_.HasCoverage());
     // We should never hit this case as we check the intersection above.
     // NOLINTBEGIN(bugprone-unchecked-optional-access)
     subpass_coverage =
         coverage_limit
             .Intersection(clip_coverage_stack_.CurrentClipCoverage().value())
             .value();
     // NOLINTEND(bugprone-unchecked-optional-access)
   }
  
   render_passes_.push_back(LazyRenderingConfig(
       renderer_,                                             //
       CreateRenderTarget(renderer_,                          //
                          ISize(subpass_coverage.GetSize()),  //
                          1u, Color::BlackTransparent())));
   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);
  
   // 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());
  
   if (backdrop_filter_contents) {
     // Render the backdrop entity.
     Entity backdrop_entity;
     backdrop_entity.SetContents(std::move(backdrop_filter_contents));
     backdrop_entity.SetTransform(
         Matrix::MakeTranslation(Vector3(-local_position)));
     backdrop_entity.SetClipDepth(std::numeric_limits<uint32_t>::max());
  
     backdrop_entity.Render(
         renderer_,
         *render_passes_.back().inline_pass_context->GetRenderPass(0).pass);
   }
 }

References impeller::Color::alpha, impeller::Color::BlackTransparent(), impeller::Paint::CanApplyOpacityPeephole(), impeller::CanvasStackEntry::clip_depth, impeller::CanvasStackEntry::clip_height, impeller::Paint::color, impeller::CreateRenderTarget(), impeller::CanvasStackEntry::cull_rect, impeller::Canvas::current_depth_, impeller::EntityPassClipStack::CurrentClipCoverage(), impeller::Canvas::GetClipHeight(), impeller::ContentContext::GetContext(), impeller::Canvas::GetCurrentTransform(), impeller::RenderTarget::GetRenderTargetSize(), impeller::EntityPassClipStack::GetReplayEntities(), impeller::TRect< T >::GetSize(), impeller::EntityPassClipStack::HasCoverage(), impeller::TRect< T >::Intersection(), impeller::TRect< T >::IntersectsWithRect(), impeller::kSource, impeller::Entity::kSubpassAppendSnapshotTransform, impeller::Entity::kSubpassPrependSnapshotTransform, impeller::FilterInput::Make(), impeller::TRect< Scalar >::MakeOriginSize(), impeller::TextureContents::MakeRect(), impeller::TRect< Scalar >::MakeSize(), impeller::Matrix::MakeTranslation(), paint, impeller::EntityPassClipStack::PushSubpass(), impeller::Entity::Render(), impeller::CanvasStackEntry::rendering_mode, Save(), impeller::Entity::SetBlendMode(), impeller::Entity::SetClipDepth(), impeller::SetClipScissor(), impeller::Entity::SetContents(), impeller::Entity::SetTransform(), impeller::CanvasStackEntry::transform, impeller::Canvas::transform_stack_, impeller::TRect< T >::TransformBounds(), and VALIDATION_LOG.

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

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

Classes

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ExperimentalCanvas() [1/3]

◆ ExperimentalCanvas() [2/3]

◆ ExperimentalCanvas() [3/3]

◆ ~ExperimentalCanvas()

Member Function Documentation

◆ DrawTextFrame()

◆ EndReplay()

◆ Restore()

◆ Save()

◆ SaveLayer()