impeller::AtlasContents Class Reference

#include <atlas_contents.h>

Inheritance diagram for impeller::AtlasContents:

Public Member Functions
	AtlasContents ()
	~AtlasContents () override
void	SetTexture (std::shared_ptr< Texture > texture)
std::shared_ptr< Texture >	GetTexture () const
void	SetTransforms (std::vector< Matrix > transforms)
void	SetBlendMode (BlendMode blend_mode)
void	SetTextureCoordinates (std::vector< Rect > texture_coords)
void	SetColors (std::vector< Color > colors)
void	SetCullRect (std::optional< Rect > cull_rect)
void	SetSamplerDescriptor (SamplerDescriptor desc)
void	SetAlpha (Scalar alpha)
const SamplerDescriptor &	GetSamplerDescriptor () const
const std::vector< Matrix > &	GetTransforms () const
const std::vector< Rect > &	GetTextureCoordinates () const
const std::vector< Color > &	GetColors () const
std::shared_ptr< SubAtlasResult >	GenerateSubAtlas () const
	Compress a drawAtlas call with blending into a smaller sized atlas. This atlas has no overlapping to ensure blending behaves as if it were done in the fragment shader. More...
std::optional< Rect >	GetCoverage (const Entity &entity) const override
	Get the screen space bounding rectangle that this contents affects. More...
bool	Render (const ContentContext &renderer, const Entity &entity, RenderPass &pass) const override
Public Member Functions inherited from impeller::Contents
	Contents ()
virtual	~Contents ()
virtual void	PopulateGlyphAtlas (const std::shared_ptr< LazyGlyphAtlas > &lazy_glyph_atlas, Scalar scale)
	Add any text data to the specified lazy atlas. The scale parameter must be used again later when drawing the text. More...
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(). More...
const std::optional< Rect > &	GetCoverageHint () const
virtual bool	IsOpaque () 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. More...
virtual StencilCoverage	GetStencilCoverage (const Entity &entity, const std::optional< Rect > &current_stencil_coverage) const
	Given the current screen space bounding rectangle of the stencil, return the expected stencil coverage after this draw call. This should only be implemented for contents that may write to the stencil buffer. More...
virtual std::optional< Snapshot >	RenderToSnapshot (const ContentContext &renderer, const Entity &entity, std::optional< Rect > coverage_limit=std::nullopt, const std::optional< SamplerDescriptor > &sampler_descriptor=std::nullopt, bool msaa_enabled=true, const std::string &label="Snapshot") const
	Render this contents to a snapshot, respecting the entity's transform, path, stencil depth, and blend mode. The result texture size is always the size of GetCoverage(entity). More...
virtual bool	ShouldRender (const Entity &entity, const std::optional< Rect > &stencil_coverage) const
std::optional< Size >	GetColorSourceSize () const
	Return the color source's intrinsic size, if available. More...
void	SetColorSourceSize (Size size)
virtual bool	CanInheritOpacity (const Entity &entity) const
	Whether or not this contents can accept the opacity peephole optimization. More...
virtual void	SetInheritedOpacity (Scalar opacity)
	Inherit the provided opacity. More...
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. More...
virtual const FilterContents *	AsFilter () const
	Cast to a filter. Returns nullptr if this Contents is not a filter. More...
virtual bool	ApplyColorFilter (const ColorFilterProc &color_filter_proc)
	If possible, applies a color filter to this contents inputs on the CPU. More...

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)>
Static Public Member Functions inherited from impeller::Contents
static std::shared_ptr< Contents >	MakeAnonymous (RenderProc render_proc, CoverageProc coverage_proc)

Detailed Description

Definition at line 32 of file atlas_contents.h.

Constructor & Destructor Documentation

AtlasContents()

impeller::AtlasContents::AtlasContents ( )

explicitdefault

~AtlasContents()

impeller::AtlasContents::~AtlasContents ( )

overridedefault

Member Function Documentation

GenerateSubAtlas()

std::shared_ptr< SubAtlasResult > impeller::AtlasContents::GenerateSubAtlas

(

)

const

Compress a drawAtlas call with blending into a smaller sized atlas. This atlas has no overlapping to ensure blending behaves as if it were done in the fragment shader.

Definition at line 89 of file atlas_contents.cc.

                                                                    {
  FML_DCHECK(colors_.size() > 0 && blend_mode_ != BlendMode::kSource &&
             blend_mode_ != BlendMode::kDestination);
 
  std::unordered_map<AtlasBlenderKey, std::vector<Matrix>,
                     AtlasBlenderKey::Hash, AtlasBlenderKey::Equal>
      sub_atlas = {};
 
  for (auto i = 0u; i < texture_coords_.size(); i++) {
    AtlasBlenderKey key = {.color = colors_[i],
                           .rect = texture_coords_[i],
                           .color_key = Color::ToIColor(colors_[i])};
    if (sub_atlas.find(key) == sub_atlas.end()) {
      sub_atlas[key] = {transforms_[i]};
    } else {
      sub_atlas[key].push_back(transforms_[i]);
    }
  }
 
  auto result = std::make_shared<SubAtlasResult>();
  Scalar x_offset = 0.0;
  Scalar y_offset = 0.0;
  Scalar x_extent = 0.0;
  Scalar y_extent = 0.0;
 
  for (auto it = sub_atlas.begin(); it != sub_atlas.end(); it++) {
    // This size was arbitrarily chosen to keep the textures from getting too
    // wide. We could instead use a more generic rect packer but in the majority
    // of cases the sample rects will be fairly close in size making this a good
    // enough approximation.
    if (x_offset >= 1000) {
      y_offset = y_extent + 1;
      x_offset = 0.0;
    }
 
    auto key = it->first;
    auto transforms = it->second;
 
    auto new_rect = Rect::MakeXYWH(x_offset, y_offset, key.rect.size.width,
                                   key.rect.size.height);
    auto sub_transform = Matrix::MakeTranslation(Vector2(x_offset, y_offset));
 
    x_offset += std::ceil(key.rect.size.width) + 1.0;
 
    result->sub_texture_coords.push_back(key.rect);
    result->sub_colors.push_back(key.color);
    result->sub_transforms.push_back(sub_transform);
 
    x_extent = std::max(x_extent, x_offset);
    y_extent = std::max(y_extent, std::ceil(y_offset + key.rect.size.height));
 
    for (auto transform : transforms) {
      result->result_texture_coords.push_back(new_rect);
      result->result_transforms.push_back(transform);
    }
  }
  result->size = ISize(std::ceil(x_extent), std::ceil(y_extent));
  return result;
}

References impeller::AtlasBlenderKey::color, impeller::kDestination, impeller::kSource, impeller::Matrix::MakeTranslation(), impeller::TRect< Scalar >::MakeXYWH(), and impeller::Color::ToIColor().

Referenced by Render().

GetColors()

const std::vector< Color > & impeller::AtlasContents::GetColors

(

)

const

Definition at line 186 of file atlas_contents.cc.

                                                       {
  return colors_;
}

Referenced by impeller::AtlasColorContents::Render().

GetCoverage()

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

overridevirtual

Get the screen space bounding rectangle that this contents affects.

Implements impeller::Contents.

Definition at line 149 of file atlas_contents.cc.

                                                                       {
  if (cull_rect_.has_value()) {
    return cull_rect_.value().TransformBounds(entity.GetTransformation());
  }
  return ComputeBoundingBox().TransformBounds(entity.GetTransformation());
}

References impeller::Entity::GetTransformation(), and impeller::TRect< T >::TransformBounds().

GetSamplerDescriptor()

const SamplerDescriptor & impeller::AtlasContents::GetSamplerDescriptor

(

)

const

Definition at line 174 of file atlas_contents.cc.

                                                                   {
  return sampler_descriptor_;
}

Referenced by impeller::AtlasTextureContents::Render().

GetTexture()

std::shared_ptr< Texture > impeller::AtlasContents::GetTexture

(

)

const

Definition at line 38 of file atlas_contents.cc.

                                                       {
  return texture_;
}

Referenced by impeller::AtlasTextureContents::Render().

GetTextureCoordinates()

const std::vector< Rect > & impeller::AtlasContents::GetTextureCoordinates

(

)

const

Definition at line 182 of file atlas_contents.cc.

                                                                  {
  return texture_coords_;
}

Referenced by impeller::AtlasTextureContents::Render(), and impeller::AtlasColorContents::Render().

GetTransforms()

const std::vector< Matrix > & impeller::AtlasContents::GetTransforms

(

)

const

Definition at line 178 of file atlas_contents.cc.

                                                            {
  return transforms_;
}

Referenced by impeller::AtlasTextureContents::Render(), and impeller::AtlasColorContents::Render().

Render()

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

overridevirtual

Implements impeller::Contents.

Definition at line 190 of file atlas_contents.cc.

                                                   {
  if (texture_ == nullptr || blend_mode_ == BlendMode::kClear ||
      alpha_ <= 0.0) {
    return true;
  }
 
  // Ensure that we use the actual computed bounds and not a cull-rect
  // approximation of them.
  auto coverage = ComputeBoundingBox();
 
  if (blend_mode_ == BlendMode::kSource || colors_.size() == 0) {
    auto child_contents = AtlasTextureContents(*this);
    child_contents.SetAlpha(alpha_);
    child_contents.SetCoverage(coverage);
    return child_contents.Render(renderer, entity, pass);
  }
  if (blend_mode_ == BlendMode::kDestination) {
    auto child_contents = AtlasColorContents(*this);
    child_contents.SetAlpha(alpha_);
    child_contents.SetCoverage(coverage);
    return child_contents.Render(renderer, entity, pass);
  }
 
  constexpr size_t indices[6] = {0, 1, 2, 1, 2, 3};
  constexpr Scalar width[6] = {0, 1, 0, 1, 0, 1};
  constexpr Scalar height[6] = {0, 0, 1, 0, 1, 1};
 
  if (blend_mode_ <= BlendMode::kModulate) {
    // Simple Porter-Duff blends can be accomplished without a subpass.
    using VS = PorterDuffBlendPipeline::VertexShader;
    using FS = PorterDuffBlendPipeline::FragmentShader;
 
    VertexBufferBuilder<VS::PerVertexData> vtx_builder;
    vtx_builder.Reserve(texture_coords_.size() * 6);
    const auto texture_size = texture_->GetSize();
    auto& host_buffer = pass.GetTransientsBuffer();
 
    for (size_t i = 0; i < texture_coords_.size(); i++) {
      auto sample_rect = texture_coords_[i];
      auto matrix = transforms_[i];
      auto transformed_points =
          Rect::MakeSize(sample_rect.size).GetTransformedPoints(matrix);
      auto color = colors_[i].Premultiply();
      for (size_t j = 0; j < 6; j++) {
        VS::PerVertexData data;
        data.vertices = transformed_points[indices[j]];
        data.texture_coords =
            (sample_rect.origin + Point(sample_rect.size.width * width[j],
                                        sample_rect.size.height * height[j])) /
            texture_size;
        data.color = color;
        vtx_builder.AppendVertex(data);
      }
    }
 
    auto vtx_buffer = vtx_builder.CreateVertexBuffer(host_buffer);
 
    Command cmd;
    DEBUG_COMMAND_INFO(
        cmd, SPrintF("DrawAtlas Blend (%s)", BlendModeToString(blend_mode_)));
    cmd.BindVertices(vtx_buffer);
    cmd.stencil_reference = entity.GetStencilDepth();
    auto options = OptionsFromPass(pass);
    cmd.pipeline = renderer.GetPorterDuffBlendPipeline(options);
 
    FS::FragInfo frag_info;
    VS::FrameInfo frame_info;
 
    auto dst_sampler_descriptor = sampler_descriptor_;
    if (renderer.GetDeviceCapabilities().SupportsDecalSamplerAddressMode()) {
      dst_sampler_descriptor.width_address_mode = SamplerAddressMode::kDecal;
      dst_sampler_descriptor.height_address_mode = SamplerAddressMode::kDecal;
    }
    auto dst_sampler = renderer.GetContext()->GetSamplerLibrary()->GetSampler(
        dst_sampler_descriptor);
    FS::BindTextureSamplerDst(cmd, texture_, dst_sampler);
    frame_info.texture_sampler_y_coord_scale = texture_->GetYCoordScale();
 
    frag_info.output_alpha = alpha_;
    frag_info.input_alpha = 1.0;
 
    auto inverted_blend_mode =
        InvertPorterDuffBlend(blend_mode_).value_or(BlendMode::kSource);
    auto blend_coefficients =
        kPorterDuffCoefficients[static_cast<int>(inverted_blend_mode)];
    frag_info.src_coeff = blend_coefficients[0];
    frag_info.src_coeff_dst_alpha = blend_coefficients[1];
    frag_info.dst_coeff = blend_coefficients[2];
    frag_info.dst_coeff_src_alpha = blend_coefficients[3];
    frag_info.dst_coeff_src_color = blend_coefficients[4];
 
    FS::BindFragInfo(cmd, host_buffer.EmplaceUniform(frag_info));
 
    frame_info.mvp = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
                     entity.GetTransformation();
 
    auto uniform_view = host_buffer.EmplaceUniform(frame_info);
    VS::BindFrameInfo(cmd, uniform_view);
 
    return pass.AddCommand(std::move(cmd));
  }
 
  // Advanced blends.
 
  auto sub_atlas = GenerateSubAtlas();
  auto sub_coverage = Rect::MakeSize(sub_atlas->size);
 
  auto src_contents = std::make_shared<AtlasTextureContents>(*this);
  src_contents->SetSubAtlas(sub_atlas);
  src_contents->SetCoverage(sub_coverage);
 
  auto dst_contents = std::make_shared<AtlasColorContents>(*this);
  dst_contents->SetSubAtlas(sub_atlas);
  dst_contents->SetCoverage(sub_coverage);
 
  Entity untransformed_entity;
  auto contents = ColorFilterContents::MakeBlend(
      blend_mode_,
      {FilterInput::Make(dst_contents), FilterInput::Make(src_contents)});
  auto snapshot =
      contents->RenderToSnapshot(renderer,              // renderer
                                 untransformed_entity,  // entity
                                 std::nullopt,          // coverage_limit
                                 std::nullopt,          // sampler_descriptor
                                 true,                  // msaa_enabled
                                 "AtlasContents Snapshot");  // label
  if (!snapshot.has_value()) {
    return false;
  }
 
  auto child_contents = AtlasTextureContents(*this);
  child_contents.SetAlpha(alpha_);
  child_contents.SetCoverage(coverage);
  child_contents.SetTexture(snapshot.value().texture);
  child_contents.SetUseDestination(true);
  child_contents.SetSubAtlas(sub_atlas);
  return child_contents.Render(renderer, entity, pass);
}

References impeller::RenderPass::AddCommand(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::AppendVertex(), impeller::Command::BindVertices(), impeller::BlendModeToString(), impeller::VertexBufferBuilder< VertexType_, IndexType_ >::CreateVertexBuffer(), DEBUG_COMMAND_INFO, GenerateSubAtlas(), impeller::ContentContext::GetContext(), impeller::ContentContext::GetDeviceCapabilities(), impeller::ContentContext::GetPorterDuffBlendPipeline(), impeller::RenderPass::GetRenderTargetSize(), impeller::Entity::GetStencilDepth(), impeller::Entity::GetTransformation(), impeller::TRect< T >::GetTransformedPoints(), impeller::RenderPass::GetTransientsBuffer(), impeller::InvertPorterDuffBlend(), impeller::kClear, impeller::kDecal, impeller::kDestination, impeller::kModulate, impeller::kPorterDuffCoefficients, impeller::kSource, impeller::FilterInput::Make(), impeller::ColorFilterContents::MakeBlend(), impeller::Matrix::MakeOrthographic(), impeller::TRect< Scalar >::MakeSize(), impeller::OptionsFromPass(), impeller::Command::pipeline, impeller::VertexBufferBuilder< VertexType_, IndexType_ >::Reserve(), impeller::SPrintF(), impeller::Command::stencil_reference, impeller::Capabilities::SupportsDecalSamplerAddressMode(), and impeller::SamplerDescriptor::width_address_mode.

SetAlpha()

void impeller::AtlasContents::SetAlpha

(

Scalar

alpha

)

Definition at line 56 of file atlas_contents.cc.

                                         {
  alpha_ = alpha;
}

SetBlendMode()

void impeller::AtlasContents::SetBlendMode

(

BlendMode

blend_mode

)

Definition at line 60 of file atlas_contents.cc.

                                                     {
  blend_mode_ = blend_mode;
}

SetColors()

void impeller::AtlasContents::SetColors

(

std::vector< Color >

colors

)

Definition at line 52 of file atlas_contents.cc.

                                                     {
  colors_ = std::move(colors);
}

SetCullRect()

void impeller::AtlasContents::SetCullRect

(

std::optional< Rect >

cull_rect

)

Definition at line 64 of file atlas_contents.cc.

                                                           {
  cull_rect_ = cull_rect;
}

SetSamplerDescriptor()

void impeller::AtlasContents::SetSamplerDescriptor

(

SamplerDescriptor

desc

)

Definition at line 170 of file atlas_contents.cc.

                                                               {
  sampler_descriptor_ = std::move(desc);
}

SetTexture()

void impeller::AtlasContents::SetTexture

(

std::shared_ptr< Texture >

texture

)

Definition at line 34 of file atlas_contents.cc.

                                                             {
  texture_ = std::move(texture);
}

SetTextureCoordinates()

void impeller::AtlasContents::SetTextureCoordinates

(

std::vector< Rect >

texture_coords

)

Definition at line 47 of file atlas_contents.cc.

                                                                        {
  texture_coords_ = std::move(texture_coords);
  bounding_box_cache_.reset();
}

SetTransforms()

void impeller::AtlasContents::SetTransforms

(

std::vector< Matrix >

transforms

)

Definition at line 42 of file atlas_contents.cc.

                                                              {
  transforms_ = std::move(transforms);
  bounding_box_cache_.reset();
}

---

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

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