impeller::RenderTargetAllocator Class Reference

a wrapper around the impeller [Allocator] instance that can be used to provide caching of allocated render target textures. More...

#include <render_target.h>

Inheritance diagram for impeller::RenderTargetAllocator:

Public Member Functions
	RenderTargetAllocator (std::shared_ptr< Allocator > allocator)
virtual	~RenderTargetAllocator ()=default
virtual 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)
virtual 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)
virtual void	DisableCache ()
	Disable any caching until the next call to EnabledCache.
virtual void	EnableCache ()
	Re-enable any caching if disabled.
virtual void	Start ()
	Mark the beginning of a frame workload.
virtual void	End ()
	Mark the end of a frame workload.

Detailed Description

a wrapper around the impeller [Allocator] instance that can be used to provide caching of allocated render target textures.

Definition at line 149 of file render_target.h.

Constructor & Destructor Documentation

RenderTargetAllocator()

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

explicit

Definition at line 314 of file render_target.cc.

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

~RenderTargetAllocator()

virtual impeller::RenderTargetAllocator::~RenderTargetAllocator ( )

virtualdefault

Member Function Documentation

CreateOffscreen()

RenderTarget impeller::RenderTargetAllocator::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  )

virtual

Reimplemented in impeller::RenderTargetCache.

Definition at line 322 of file render_target.cc.

                                                                  {
  if (size.IsEmpty()) {
    return {};
  }
 
  RenderTarget target;
 
  std::shared_ptr<Texture> color0_tex;
  if (existing_color_texture) {
    color0_tex = existing_color_texture;
  } else {
    PixelFormat pixel_format =
        context.GetCapabilities()->GetDefaultColorFormat();
    TextureDescriptor color0_tex_desc;
    color0_tex_desc.storage_mode = color_attachment_config.storage_mode;
    color0_tex_desc.format = pixel_format;
    color0_tex_desc.size = size;
    color0_tex_desc.mip_count = mip_count;
    color0_tex_desc.usage =
        TextureUsage::kRenderTarget | TextureUsage::kShaderRead;
    color0_tex = allocator_->CreateTexture(color0_tex_desc);
    if (!color0_tex) {
      return {};
    }
  }
  color0_tex->SetLabel(label, "Color Texture");
 
  ColorAttachment color0;
  color0.clear_color = color_attachment_config.clear_color;
  color0.load_action = color_attachment_config.load_action;
  color0.store_action = color_attachment_config.store_action;
  color0.texture = color0_tex;
  target.SetColorAttachment(color0, 0u);
 
  if (stencil_attachment_config.has_value()) {
    target.SetupDepthStencilAttachments(
        context, *allocator_, size, false, label,
        stencil_attachment_config.value(), existing_depth_stencil_texture);
  } else {
    target.SetStencilAttachment(std::nullopt);
    target.SetDepthAttachment(std::nullopt);
  }
 
  return target;
}

References impeller::ColorAttachment::clear_color, impeller::RenderTarget::AttachmentConfig::clear_color, impeller::TextureDescriptor::format, impeller::Context::GetCapabilities(), impeller::kRenderTarget, impeller::kShaderRead, impeller::Attachment::load_action, impeller::RenderTarget::AttachmentConfig::load_action, impeller::TextureDescriptor::mip_count, impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, impeller::RenderTarget::AttachmentConfig::storage_mode, impeller::Attachment::store_action, impeller::RenderTarget::AttachmentConfig::store_action, target, impeller::Attachment::texture, and impeller::TextureDescriptor::usage.

Referenced by impeller::RenderTargetCache::CreateOffscreen(), impeller::DisplayListToTexture(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), impeller::testing::TEST_P(), and impeller::testing::TEST_P().

CreateOffscreenMSAA()

RenderTarget impeller::RenderTargetAllocator::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  )

virtual

Reimplemented in impeller::RenderTargetCache.

Definition at line 376 of file render_target.cc.

                                                                  {
  if (size.IsEmpty()) {
    return {};
  }
 
  RenderTarget target;
  PixelFormat pixel_format = context.GetCapabilities()->GetDefaultColorFormat();
 
  // Create MSAA color texture.
  std::shared_ptr<Texture> color0_msaa_tex;
  if (existing_color_msaa_texture) {
    color0_msaa_tex = existing_color_msaa_texture;
  } else {
    TextureDescriptor color0_tex_desc;
    color0_tex_desc.storage_mode = color_attachment_config.storage_mode;
    color0_tex_desc.type = TextureType::kTexture2DMultisample;
    color0_tex_desc.sample_count = SampleCount::kCount4;
    color0_tex_desc.format = pixel_format;
    color0_tex_desc.size = size;
    color0_tex_desc.usage = TextureUsage::kRenderTarget;
    if (context.GetCapabilities()->SupportsImplicitResolvingMSAA()) {
      // See below ("SupportsImplicitResolvingMSAA") for more details.
      color0_tex_desc.storage_mode = StorageMode::kDevicePrivate;
    }
    color0_msaa_tex = allocator_->CreateTexture(color0_tex_desc);
    if (!color0_msaa_tex) {
      VALIDATION_LOG << "Could not create multisample color texture.";
      return {};
    }
  }
  color0_msaa_tex->SetLabel(label, "Color Texture (Multisample)");
 
  // Create color resolve texture.
  std::shared_ptr<Texture> color0_resolve_tex;
  if (existing_color_resolve_texture) {
    color0_resolve_tex = existing_color_resolve_texture;
  } else {
    TextureDescriptor color0_resolve_tex_desc;
    color0_resolve_tex_desc.storage_mode =
        color_attachment_config.resolve_storage_mode;
    color0_resolve_tex_desc.format = pixel_format;
    color0_resolve_tex_desc.size = size;
    color0_resolve_tex_desc.compression_type = CompressionType::kLossy;
    color0_resolve_tex_desc.usage =
        TextureUsage::kRenderTarget | TextureUsage::kShaderRead;
    color0_resolve_tex_desc.mip_count = mip_count;
    color0_resolve_tex = allocator_->CreateTexture(color0_resolve_tex_desc);
    if (!color0_resolve_tex) {
      VALIDATION_LOG << "Could not create color texture.";
      return {};
    }
  }
  color0_resolve_tex->SetLabel(label, "Color Texture");
 
  // Color attachment.
 
  ColorAttachment color0;
  color0.clear_color = color_attachment_config.clear_color;
  color0.load_action = color_attachment_config.load_action;
  color0.store_action = color_attachment_config.store_action;
  color0.texture = color0_msaa_tex;
  color0.resolve_texture = color0_resolve_tex;
 
  if (context.GetCapabilities()->SupportsImplicitResolvingMSAA()) {
    // If implicit MSAA is supported, then the resolve texture is not needed
    // because the multisample texture is automatically resolved. We instead
    // provide a view of the multisample texture as the resolve texture (because
    // the HAL does expect a resolve texture).
    //
    // In practice, this is used for GLES 2.0 EXT_multisampled_render_to_texture
    // https://registry.khronos.org/OpenGL/extensions/EXT/EXT_multisampled_render_to_texture.txt
    color0.resolve_texture = color0_msaa_tex;
  }
 
  target.SetColorAttachment(color0, 0u);
 
  // Create MSAA stencil texture.
 
  if (stencil_attachment_config.has_value()) {
    target.SetupDepthStencilAttachments(context, *allocator_, size, true, label,
                                        stencil_attachment_config.value(),
                                        existing_depth_stencil_texture);
  } else {
    target.SetDepthAttachment(std::nullopt);
    target.SetStencilAttachment(std::nullopt);
  }
 
  return target;
}

References impeller::ColorAttachment::clear_color, impeller::RenderTarget::AttachmentConfigMSAA::clear_color, impeller::TextureDescriptor::compression_type, impeller::TextureDescriptor::format, impeller::Context::GetCapabilities(), impeller::kCount4, impeller::kDevicePrivate, impeller::kLossy, impeller::kRenderTarget, impeller::kShaderRead, impeller::kTexture2DMultisample, impeller::Attachment::load_action, impeller::RenderTarget::AttachmentConfigMSAA::load_action, impeller::TextureDescriptor::mip_count, impeller::RenderTarget::AttachmentConfigMSAA::resolve_storage_mode, impeller::Attachment::resolve_texture, impeller::TextureDescriptor::sample_count, impeller::TextureDescriptor::size, impeller::TextureDescriptor::storage_mode, impeller::RenderTarget::AttachmentConfigMSAA::storage_mode, impeller::Attachment::store_action, impeller::RenderTarget::AttachmentConfigMSAA::store_action, target, impeller::Attachment::texture, impeller::TextureDescriptor::type, impeller::TextureDescriptor::usage, and VALIDATION_LOG.

Referenced by impeller::RenderTargetCache::CreateOffscreenMSAA(), impeller::DisplayListToTexture(), impeller::ContextVK::InitializeCommonlyUsedShadersIfNeeded(), and impeller::testing::TEST().

DisableCache()

virtual void impeller::RenderTargetAllocator::DisableCache ( )

inlinevirtual

Disable any caching until the next call to EnabledCache.

Reimplemented in impeller::RenderTargetCache.

Definition at line 181 of file render_target.h.

{}

EnableCache()

virtual void impeller::RenderTargetAllocator::EnableCache ( )

inlinevirtual

Re-enable any caching if disabled.

Reimplemented in impeller::RenderTargetCache.

Definition at line 184 of file render_target.h.

{}

End()

void impeller::RenderTargetAllocator::End ( )

virtual

Mark the end of a frame workload.

   This may be used to deallocate any unused textures. 

Reimplemented in impeller::RenderTargetCache.

Definition at line 320 of file render_target.cc.

{}

Start()

void impeller::RenderTargetAllocator::Start ( )

virtual

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 in impeller::RenderTargetCache.

Definition at line 318 of file render_target.cc.

{}

---

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

• impeller/renderer/render_target.h
• impeller/renderer/render_target.cc