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, uint32_t keep_alive_frame_count=4)
	~RenderTargetCache ()=default
void	Start () override
	Mark the beginning of a frame workload. More...
void	End () override
	Mark the end of a frame workload. More...
void	DisableCache () override
	Disable any caching until the next call to EnabledCache. More...
void	EnableCache () override
	Re-enable any caching if disabled. More...
RenderTarget	CreateOffscreen (const Context &context, ISize size, int mip_count, std::string_view 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, std::optional< PixelFormat > target_pixel_format=std::nullopt) override
RenderTarget	CreateOffscreenMSAA (const Context &context, ISize size, int mip_count, std::string_view 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, std::optional< PixelFormat > target_pixel_format=std::nullopt) override
size_t	CachedTextureCount () const
std::vector< RenderTargetData >::const_iterator	GetRenderTargetDataBegin () const
	Visible for testing. More...
std::vector< RenderTargetData >::const_iterator	GetRenderTargetDataEnd () const
	Visible for testing. More...
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 18 of file render_target_cache.h.

Constructor & Destructor Documentation

RenderTargetCache()

impeller::RenderTargetCache::RenderTargetCache ( std::shared_ptr< Allocator >  allocator, uint32_t  keep_alive_frame_count = 4  )

explicit

Definition at line 11 of file render_target_cache.cc.

    : RenderTargetAllocator(std::move(allocator)),
      keep_alive_frame_count_(keep_alive_frame_count) {}

~RenderTargetCache()

impeller::RenderTargetCache::~RenderTargetCache ( )

default

Member Function Documentation

CachedTextureCount()

size_t impeller::RenderTargetCache::CachedTextureCount

(

)

const

Definition at line 172 of file render_target_cache.cc.

                                                   {
  return render_target_data_.size();
}

CreateOffscreen()

RenderTarget impeller::RenderTargetCache::CreateOffscreen ( const Context &  context, ISize  size, int  mip_count, std::string_view  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, std::optional< PixelFormat >  target_pixel_format = std::nullopt  )

overridevirtual

Reimplemented from impeller::RenderTargetAllocator.

Definition at line 54 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(),
  };
 
  if (CacheEnabled()) {
    for (RenderTargetData& render_target_data : render_target_data_) {
      const RenderTargetConfig other_config = render_target_data.config;
      if (!render_target_data.used_this_frame && other_config == config) {
        render_target_data.used_this_frame = true;
        render_target_data.keep_alive_frame_count = keep_alive_frame_count_;
        ColorAttachment color0 =
            render_target_data.render_target.GetColorAttachment(0);
        std::optional<DepthAttachment> 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,
            target_pixel_format);
      }
    }
  }
  RenderTarget created_target = RenderTargetAllocator::CreateOffscreen(
      context, size, mip_count, label, color_attachment_config,
      stencil_attachment_config, nullptr, nullptr, target_pixel_format);
  if (!created_target.IsValid()) {
    return created_target;
  }
  if (CacheEnabled()) {
    render_target_data_.push_back(RenderTargetData{
        .used_this_frame = true,                            //
        .keep_alive_frame_count = keep_alive_frame_count_,  //
        .config = config,                                   //
        .render_target = created_target                     //
    });
  }
  return created_target;
}

References impeller::RenderTargetAllocator::CreateOffscreen(), impeller::TSize< T >::IsEmpty(), impeller::RenderTarget::IsValid(), impeller::RenderTargetConfig::size, and impeller::Attachment::texture.

CreateOffscreenMSAA()

RenderTarget impeller::RenderTargetCache::CreateOffscreenMSAA ( const Context &  context, ISize  size, int  mip_count, std::string_view  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, std::optional< PixelFormat >  target_pixel_format = std::nullopt  )

overridevirtual

Reimplemented from impeller::RenderTargetAllocator.

Definition at line 112 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(),
  };
  if (CacheEnabled()) {
    for (RenderTargetData& render_target_data : render_target_data_) {
      const RenderTargetConfig other_config = render_target_data.config;
      if (!render_target_data.used_this_frame && other_config == config) {
        render_target_data.used_this_frame = true;
        render_target_data.keep_alive_frame_count = keep_alive_frame_count_;
        ColorAttachment color0 =
            render_target_data.render_target.GetColorAttachment(0);
        std::optional<DepthAttachment> 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, target_pixel_format);
      }
    }
  }
  RenderTarget created_target = RenderTargetAllocator::CreateOffscreenMSAA(
      context, size, mip_count, label, color_attachment_config,
      stencil_attachment_config, nullptr, nullptr, nullptr,
      target_pixel_format);
  if (!created_target.IsValid()) {
    return created_target;
  }
  if (CacheEnabled()) {
    render_target_data_.push_back(RenderTargetData{
        .used_this_frame = true,                            //
        .keep_alive_frame_count = keep_alive_frame_count_,  //
        .config = config,                                   //
        .render_target = created_target                     //
    });
  }
  return created_target;
}

References impeller::RenderTargetAllocator::CreateOffscreenMSAA(), impeller::TSize< T >::IsEmpty(), impeller::RenderTarget::IsValid(), impeller::Attachment::resolve_texture, impeller::RenderTargetConfig::size, and impeller::Attachment::texture.

DisableCache()

void impeller::RenderTargetCache::DisableCache ( )

overridevirtual

Disable any caching until the next call to EnabledCache.

Reimplemented from impeller::RenderTargetAllocator.

Definition at line 38 of file render_target_cache.cc.

                                     {
  cache_disabled_count_++;
}

EnableCache()

void impeller::RenderTargetCache::EnableCache ( )

overridevirtual

Re-enable any caching if disabled.

Reimplemented from impeller::RenderTargetAllocator.

Definition at line 46 of file render_target_cache.cc.

                                    {
  FML_DCHECK(cache_disabled_count_ > 0);
  if (cache_disabled_count_ == 0) {
    return;
  }
  cache_disabled_count_--;
}

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 23 of file render_target_cache.cc.

                            {
  cache_disabled_count_ = 0;
  std::vector<RenderTargetData> retain;
 
  for (RenderTargetData& td : render_target_data_) {
    if (td.used_this_frame) {
      retain.push_back(td);
    } else if (td.keep_alive_frame_count > 0) {
      td.keep_alive_frame_count--;
      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 87 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 93 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 16 of file render_target_cache.cc.

                              {
  cache_disabled_count_ = 0;
  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