impeller::RenderTargetCache Class Reference

An implementation of the [RenderTargetAllocator] that caches all allocated texture data for one frame. More...

#include <render_target_cache.h>

Inheritance diagram for impeller::RenderTargetCache:

Public Member Functions
	RenderTargetCache (std::shared_ptr< Allocator > allocator)
	~RenderTargetCache ()=default
void	Start () override
	Mark the beginning of a frame workload.
void	End () override
	Mark the end of a frame workload.
RenderTarget	CreateOffscreen (const Context &context, ISize size, int mip_count, const std::string &label="Offscreen", RenderTarget::AttachmentConfig color_attachment_config=RenderTarget::kDefaultColorAttachmentConfig, std::optional< RenderTarget::AttachmentConfig > stencil_attachment_config=RenderTarget::kDefaultStencilAttachmentConfig, const std::shared_ptr< Texture > &existing_color_texture=nullptr, const std::shared_ptr< Texture > &existing_depth_stencil_texture=nullptr) override
RenderTarget	CreateOffscreenMSAA (const Context &context, ISize size, int mip_count, const std::string &label="Offscreen MSAA", RenderTarget::AttachmentConfigMSAA color_attachment_config=RenderTarget::kDefaultColorAttachmentConfigMSAA, std::optional< RenderTarget::AttachmentConfig > stencil_attachment_config=RenderTarget::kDefaultStencilAttachmentConfig, const std::shared_ptr< Texture > &existing_color_msaa_texture=nullptr, const std::shared_ptr< Texture > &existing_color_resolve_texture=nullptr, const std::shared_ptr< Texture > &existing_depth_stencil_texture=nullptr) override
size_t	CachedTextureCount () const
std::vector< RenderTargetData >::const_iterator	GetRenderTargetDataBegin () const
	Visible for testing.
std::vector< RenderTargetData >::const_iterator	GetRenderTargetDataEnd () const
	Visible for testing.
Public Member Functions inherited from impeller::RenderTargetAllocator
	RenderTargetAllocator (std::shared_ptr< Allocator > allocator)
virtual	~RenderTargetAllocator ()=default

Detailed Description

An implementation of the [RenderTargetAllocator] that caches all allocated texture data for one frame.

Any textures unused after a frame are immediately discarded.

Definition at line 16 of file render_target_cache.h.

Constructor & Destructor Documentation

RenderTargetCache()

impeller::RenderTargetCache::RenderTargetCache ( std::shared_ptr< Allocator >  allocator )

explicit

Definition at line 10 of file render_target_cache.cc.

    : RenderTargetAllocator(std::move(allocator)) {}

~RenderTargetCache()

impeller::RenderTargetCache::~RenderTargetCache ( )

default

Member Function Documentation

CachedTextureCount()

size_t impeller::RenderTargetCache::CachedTextureCount

(

)

const

Definition at line 129 of file render_target_cache.cc.

                                                   {
  return render_target_data_.size();
}

CreateOffscreen()

RenderTarget impeller::RenderTargetCache::CreateOffscreen ( const Context &  context, ISize  size, int  mip_count, const std::string &  label = "Offscreen", RenderTarget::AttachmentConfig  color_attachment_config = RenderTarget::kDefaultColorAttachmentConfig, std::optional< RenderTarget::AttachmentConfig >  stencil_attachment_config = RenderTarget::kDefaultStencilAttachmentConfig, const std::shared_ptr< Texture > &  existing_color_texture = nullptr, const std::shared_ptr< Texture > &  existing_depth_stencil_texture = nullptr  )

overridevirtual

Reimplemented from impeller::RenderTargetAllocator.

Definition at line 30 of file render_target_cache.cc.

                                                                  {
  if (size.IsEmpty()) {
    return {};
  }
 
  FML_DCHECK(existing_color_texture == nullptr &&
             existing_depth_stencil_texture == nullptr);
  auto config = RenderTargetConfig{
      .size = size,
      .mip_count = static_cast<size_t>(mip_count),
      .has_msaa = false,
      .has_depth_stencil = stencil_attachment_config.has_value(),
  };
  for (auto& render_target_data : render_target_data_) {
    const auto other_config = render_target_data.config;
    if (!render_target_data.used_this_frame && other_config == config) {
      render_target_data.used_this_frame = true;
      auto color0 = render_target_data.render_target.GetColorAttachments()
                        .find(0u)
                        ->second;
      auto depth = render_target_data.render_target.GetDepthAttachment();
      std::shared_ptr<Texture> depth_tex = depth ? depth->texture : nullptr;
      return RenderTargetAllocator::CreateOffscreen(
          context, size, mip_count, label, color_attachment_config,
          stencil_attachment_config, color0.texture, depth_tex);
    }
  }
  RenderTarget created_target = RenderTargetAllocator::CreateOffscreen(
      context, size, mip_count, label, color_attachment_config,
      stencil_attachment_config);
  if (!created_target.IsValid()) {
    return created_target;
  }
  render_target_data_.push_back(
      RenderTargetData{.used_this_frame = true,
                       .config = config,
                       .render_target = created_target});
  return created_target;
}

CreateOffscreenMSAA()

RenderTarget impeller::RenderTargetCache::CreateOffscreenMSAA ( const Context &  context, ISize  size, int  mip_count, const std::string &  label = "Offscreen MSAA", RenderTarget::AttachmentConfigMSAA  color_attachment_config = RenderTarget::kDefaultColorAttachmentConfigMSAA, std::optional< RenderTarget::AttachmentConfig >  stencil_attachment_config = RenderTarget::kDefaultStencilAttachmentConfig, const std::shared_ptr< Texture > &  existing_color_msaa_texture = nullptr, const std::shared_ptr< Texture > &  existing_color_resolve_texture = nullptr, const std::shared_ptr< Texture > &  existing_depth_stencil_texture = nullptr  )

overridevirtual

Reimplemented from impeller::RenderTargetAllocator.

Definition at line 78 of file render_target_cache.cc.

                                                                  {
  if (size.IsEmpty()) {
    return {};
  }
 
  FML_DCHECK(existing_color_msaa_texture == nullptr &&
             existing_color_resolve_texture == nullptr &&
             existing_depth_stencil_texture == nullptr);
  auto config = RenderTargetConfig{
      .size = size,
      .mip_count = static_cast<size_t>(mip_count),
      .has_msaa = true,
      .has_depth_stencil = stencil_attachment_config.has_value(),
  };
  for (auto& render_target_data : render_target_data_) {
    const auto other_config = render_target_data.config;
    if (!render_target_data.used_this_frame && other_config == config) {
      render_target_data.used_this_frame = true;
      auto color0 = render_target_data.render_target.GetColorAttachments()
                        .find(0u)
                        ->second;
      auto depth = render_target_data.render_target.GetDepthAttachment();
      std::shared_ptr<Texture> depth_tex = depth ? depth->texture : nullptr;
      return RenderTargetAllocator::CreateOffscreenMSAA(
          context, size, mip_count, label, color_attachment_config,
          stencil_attachment_config, color0.texture, color0.resolve_texture,
          depth_tex);
    }
  }
  RenderTarget created_target = RenderTargetAllocator::CreateOffscreenMSAA(
      context, size, mip_count, label, color_attachment_config,
      stencil_attachment_config);
  if (!created_target.IsValid()) {
    return created_target;
  }
  render_target_data_.push_back(
      RenderTargetData{.used_this_frame = true,
                       .config = config,
                       .render_target = created_target});
  return created_target;
}

End()

void impeller::RenderTargetCache::End ( )

overridevirtual

Mark the end of a frame workload.

   This may be used to deallocate any unused textures. 

Reimplemented from impeller::RenderTargetAllocator.

Definition at line 19 of file render_target_cache.cc.

                            {
  std::vector<RenderTargetData> retain;
 
  for (const auto& td : render_target_data_) {
    if (td.used_this_frame) {
      retain.push_back(td);
    }
  }
  render_target_data_.swap(retain);
}

GetRenderTargetDataBegin()

std::vector< RenderTargetData >::const_iterator impeller::RenderTargetCache::GetRenderTargetDataBegin ( ) const

inline

Visible for testing.

Definition at line 73 of file render_target_cache.h.

            {
    return render_target_data_.begin();
  }

GetRenderTargetDataEnd()

std::vector< RenderTargetData >::const_iterator impeller::RenderTargetCache::GetRenderTargetDataEnd ( ) const

inline

Visible for testing.

Definition at line 79 of file render_target_cache.h.

                                                                           {
    return render_target_data_.end();
  }

Start()

void impeller::RenderTargetCache::Start ( )

overridevirtual

Mark the beginning of a frame workload.

  This may be used to reset any tracking state on whether or not a
  particular texture instance is still in use. 

Reimplemented from impeller::RenderTargetAllocator.

Definition at line 13 of file render_target_cache.cc.

                              {
  for (auto& td : render_target_data_) {
    td.used_this_frame = false;
  }
}

---

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

• impeller/entity/render_target_cache.h
• impeller/entity/render_target_cache.cc