impeller::RenderTarget Class Reference

#include <render_target.h>

Classes
struct	AttachmentConfig
struct	AttachmentConfigMSAA

Public Member Functions
	RenderTarget ()
	~RenderTarget ()
bool	IsValid () const
void	SetupDepthStencilAttachments (const Context &context, Allocator &allocator, ISize size, bool msaa, const std::string &label="Offscreen", RenderTarget::AttachmentConfig stencil_attachment_config=RenderTarget::kDefaultStencilAttachmentConfig, const std::shared_ptr< Texture > &depth_stencil_texture=nullptr)
SampleCount	GetSampleCount () const
bool	HasColorAttachment (size_t index) const
ISize	GetRenderTargetSize () const
std::shared_ptr< Texture >	GetRenderTargetTexture () const
PixelFormat	GetRenderTargetPixelFormat () const
std::optional< ISize >	GetColorAttachmentSize (size_t index) const
RenderTarget &	SetColorAttachment (const ColorAttachment &attachment, size_t index)
RenderTarget &	SetDepthAttachment (std::optional< DepthAttachment > attachment)
RenderTarget &	SetStencilAttachment (std::optional< StencilAttachment > attachment)
size_t	GetMaxColorAttacmentBindIndex () const
const std::map< size_t, ColorAttachment > &	GetColorAttachments () const
const std::optional< DepthAttachment > &	GetDepthAttachment () const
const std::optional< StencilAttachment > &	GetStencilAttachment () const
size_t	GetTotalAttachmentCount () const
void	IterateAllAttachments (const std::function< bool(const Attachment &attachment)> &iterator) const
std::string	ToString () const
RenderTargetConfig	ToConfig () const

Static Public Attributes
static constexpr AttachmentConfig	kDefaultColorAttachmentConfig
static constexpr AttachmentConfigMSAA	kDefaultColorAttachmentConfigMSAA
static constexpr AttachmentConfig	kDefaultStencilAttachmentConfig

Detailed Description

Definition at line 38 of file render_target.h.

Constructor & Destructor Documentation

RenderTarget()

impeller::RenderTarget::RenderTarget ( )

default

~RenderTarget()

impeller::RenderTarget::~RenderTarget ( )

default

Member Function Documentation

GetColorAttachments()

const std::map< size_t, ColorAttachment > & impeller::RenderTarget::GetColorAttachments

(

)

const

Definition at line 198 of file render_target.cc.

          {
  return colors_;
}

GetColorAttachmentSize()

std::optional< ISize > impeller::RenderTarget::GetColorAttachmentSize

(

size_t

index

)

const

Definition at line 129 of file render_target.cc.

                                                                          {
  auto found = colors_.find(index);
 
  if (found == colors_.end()) {
    return std::nullopt;
  }
 
  return found->second.texture->GetSize();
}

GetDepthAttachment()

const std::optional< DepthAttachment > & impeller::RenderTarget::GetDepthAttachment

(

)

const

Definition at line 203 of file render_target.cc.

                                                                           {
  return depth_;
}

GetMaxColorAttacmentBindIndex()

size_t impeller::RenderTarget::GetMaxColorAttacmentBindIndex

(

)

const

Definition at line 161 of file render_target.cc.

                                                         {
  size_t max = 0;
  for (const auto& color : colors_) {
    max = std::max(color.first, max);
  }
  return max;
}

GetRenderTargetPixelFormat()

PixelFormat impeller::RenderTarget::GetRenderTargetPixelFormat

(

)

const

Definition at line 153 of file render_target.cc.

                                                           {
  if (auto texture = GetRenderTargetTexture(); texture != nullptr) {
    return texture->GetTextureDescriptor().format;
  }
 
  return PixelFormat::kUnknown;
}

GetRenderTargetSize()

ISize impeller::RenderTarget::GetRenderTargetSize

(

)

const

Definition at line 139 of file render_target.cc.

                                              {
  auto size = GetColorAttachmentSize(0u);
  return size.has_value() ? size.value() : ISize{};
}

GetRenderTargetTexture()

std::shared_ptr< Texture > impeller::RenderTarget::GetRenderTargetTexture

(

)

const

Definition at line 144 of file render_target.cc.

                                                                  {
  auto found = colors_.find(0u);
  if (found == colors_.end()) {
    return nullptr;
  }
  return found->second.resolve_texture ? found->second.resolve_texture
                                       : found->second.texture;
}

GetSampleCount()

SampleCount impeller::RenderTarget::GetSampleCount

(

)

const

Definition at line 115 of file render_target.cc.

                                               {
  if (auto found = colors_.find(0u); found != colors_.end()) {
    return found->second.texture->GetTextureDescriptor().sample_count;
  }
  return SampleCount::kCount1;
}

GetStencilAttachment()

const std::optional< StencilAttachment > & impeller::RenderTarget::GetStencilAttachment

(

)

const

Definition at line 207 of file render_target.cc.

          {
  return stencil_;
}

GetTotalAttachmentCount()

size_t impeller::RenderTarget::GetTotalAttachmentCount

(

)

const

Definition at line 212 of file render_target.cc.

                                                   {
  size_t count = 0u;
  for (const auto& [_, color] : colors_) {
    if (color.texture) {
      count++;
    }
    if (color.resolve_texture) {
      count++;
    }
  }
  if (depth_.has_value()) {
    count++;
  }
  if (stencil_.has_value()) {
    count++;
  }
  return count;
}

HasColorAttachment()

bool impeller::RenderTarget::HasColorAttachment

(

size_t

index

)

const

Definition at line 122 of file render_target.cc.

                                                        {
  if (auto found = colors_.find(index); found != colors_.end()) {
    return true;
  }
  return false;
}

IsValid()

bool impeller::RenderTarget::IsValid

(

)

const

Definition at line 23 of file render_target.cc.

                                 {
  // Validate that there is a color attachment at zero index.
  if (!HasColorAttachment(0u)) {
    VALIDATION_LOG
        << "Render target does not have color attachment at index 0.";
    return false;
  }
 
  // Validate that all attachments are of the same size.
  {
    std::optional<ISize> size;
    bool sizes_are_same = true;
    auto iterator = [&](const Attachment& attachment) -> bool {
      if (!size.has_value()) {
        size = attachment.texture->GetSize();
      }
      if (size != attachment.texture->GetSize()) {
        sizes_are_same = false;
        return false;
      }
      return true;
    };
    IterateAllAttachments(iterator);
    if (!sizes_are_same) {
      VALIDATION_LOG
          << "Sizes of all render target attachments are not the same.";
      return false;
    }
  }
 
  // Validate that all attachments are of the same type and sample counts.
  {
    std::optional<TextureType> texture_type;
    std::optional<SampleCount> sample_count;
    bool passes_type_validation = true;
    auto iterator = [&](const Attachment& attachment) -> bool {
      if (!texture_type.has_value() || !sample_count.has_value()) {
        texture_type = attachment.texture->GetTextureDescriptor().type;
        sample_count = attachment.texture->GetTextureDescriptor().sample_count;
      }
 
      if (texture_type != attachment.texture->GetTextureDescriptor().type) {
        passes_type_validation = false;
        VALIDATION_LOG << "Render target has incompatible texture types: "
                       << TextureTypeToString(texture_type.value()) << " != "
                       << TextureTypeToString(
                              attachment.texture->GetTextureDescriptor().type)
                       << " on target " << ToString();
        return false;
      }
 
      if (sample_count !=
          attachment.texture->GetTextureDescriptor().sample_count) {
        passes_type_validation = false;
        VALIDATION_LOG << "Render target (" << ToString()
                       << ") has incompatible sample counts.";
 
        return false;
      }
 
      return true;
    };
    IterateAllAttachments(iterator);
    if (!passes_type_validation) {
      return false;
    }
  }
 
  return true;
}

IterateAllAttachments()

void impeller::RenderTarget::IterateAllAttachments

(

const std::function< bool(const Attachment &attachment)> &

iterator

)

const

Definition at line 94 of file render_target.cc.

                                                                           {
  for (const auto& color : colors_) {
    if (!iterator(color.second)) {
      return;
    }
  }
 
  if (depth_.has_value()) {
    if (!iterator(depth_.value())) {
      return;
    }
  }
 
  if (stencil_.has_value()) {
    if (!iterator(stencil_.value())) {
      return;
    }
  }
}

SetColorAttachment()

RenderTarget & impeller::RenderTarget::SetColorAttachment	(	const ColorAttachment &	attachment,
		size_t	index
	)

Definition at line 169 of file render_target.cc.

                  {
  if (attachment.IsValid()) {
    colors_[index] = attachment;
  }
  return *this;
}

SetDepthAttachment()

RenderTarget & impeller::RenderTarget::SetDepthAttachment

(

std::optional< DepthAttachment >

attachment

)

Definition at line 178 of file render_target.cc.

                                             {
  if (!attachment.has_value()) {
    depth_ = std::nullopt;
  } else if (attachment->IsValid()) {
    depth_ = std::move(attachment);
  }
  return *this;
}

SetStencilAttachment()

RenderTarget & impeller::RenderTarget::SetStencilAttachment

(

std::optional< StencilAttachment >

attachment

)

Definition at line 188 of file render_target.cc.

                                               {
  if (!attachment.has_value()) {
    stencil_ = std::nullopt;
  } else if (attachment->IsValid()) {
    stencil_ = std::move(attachment);
  }
  return *this;
}

SetupDepthStencilAttachments()

void impeller::RenderTarget::SetupDepthStencilAttachments	(	const Context &	context,
		Allocator &	allocator,
		ISize	size,
		bool	msaa,
		const std::string &	label = "Offscreen",
		RenderTarget::AttachmentConfig	stencil_attachment_config = RenderTarget::kDefaultStencilAttachmentConfig,
		const std::shared_ptr< Texture > &	depth_stencil_texture = nullptr
	)

Definition at line 413 of file render_target.cc.

                                                                  {
  std::shared_ptr<Texture> depth_stencil_texture;
  if (existing_depth_stencil_texture) {
    depth_stencil_texture = existing_depth_stencil_texture;
  } else {
    TextureDescriptor depth_stencil_texture_desc;
    depth_stencil_texture_desc.storage_mode =
        stencil_attachment_config.storage_mode;
    if (msaa) {
      depth_stencil_texture_desc.type = TextureType::kTexture2DMultisample;
      depth_stencil_texture_desc.sample_count = SampleCount::kCount4;
    }
    depth_stencil_texture_desc.format =
        context.GetCapabilities()->GetDefaultDepthStencilFormat();
    depth_stencil_texture_desc.size = size;
    depth_stencil_texture_desc.usage = TextureUsage::kRenderTarget;
    depth_stencil_texture = allocator.CreateTexture(depth_stencil_texture_desc);
    if (!depth_stencil_texture) {
      return;  // Error messages are handled by `Allocator::CreateTexture`.
    }
  }
 
  DepthAttachment depth0;
  depth0.load_action = stencil_attachment_config.load_action;
  depth0.store_action = stencil_attachment_config.store_action;
  depth0.clear_depth = 0u;
  depth0.texture = depth_stencil_texture;
 
  StencilAttachment stencil0;
  stencil0.load_action = stencil_attachment_config.load_action;
  stencil0.store_action = stencil_attachment_config.store_action;
  stencil0.clear_stencil = 0u;
  stencil0.texture = std::move(depth_stencil_texture);
 
  stencil0.texture->SetLabel(
      SPrintF("%s Depth+Stencil Texture", label.c_str()));
  SetDepthAttachment(std::move(depth0));
  SetStencilAttachment(std::move(stencil0));
}

ToConfig()

RenderTargetConfig impeller::RenderTarget::ToConfig ( ) const

inline

Definition at line 125 of file render_target.h.

                                      {
    auto& color_attachment = GetColorAttachments().find(0)->second;
    return RenderTargetConfig{
        .size = color_attachment.texture->GetSize(),
        .mip_count = color_attachment.texture->GetMipCount(),
        .has_msaa = color_attachment.resolve_texture != nullptr,
        .has_depth_stencil = depth_.has_value() && stencil_.has_value()};
  }

ToString()

std::string impeller::RenderTarget::ToString

(

)

const

Definition at line 231 of file render_target.cc.

                                       {
  std::stringstream stream;
 
  for (const auto& [index, color] : colors_) {
    stream << SPrintF("Color[%zu]=(%s)", index,
                      ColorAttachmentToString(color).c_str());
  }
  if (depth_) {
    stream << ",";
    stream << SPrintF("Depth=(%s)",
                      DepthAttachmentToString(depth_.value()).c_str());
  }
  if (stencil_) {
    stream << ",";
    stream << SPrintF("Stencil=(%s)",
                      StencilAttachmentToString(stencil_.value()).c_str());
  }
  return stream.str();
}

Member Data Documentation

kDefaultColorAttachmentConfig

constexpr AttachmentConfig impeller::RenderTarget::kDefaultColorAttachmentConfig

staticconstexpr

Initial value:

= {
      .storage_mode = StorageMode::kDevicePrivate,
      .load_action = LoadAction::kClear,
      .store_action = StoreAction::kStore,
      .clear_color = Color::BlackTransparent()}

Definition at line 55 of file render_target.h.

kDefaultColorAttachmentConfigMSAA

constexpr AttachmentConfigMSAA impeller::RenderTarget::kDefaultColorAttachmentConfigMSAA

staticconstexpr

Initial value:

= {
      .storage_mode = StorageMode::kDeviceTransient,
      .resolve_storage_mode = StorageMode::kDevicePrivate,
      .load_action = LoadAction::kClear,
      .store_action = StoreAction::kMultisampleResolve,
      .clear_color = Color::BlackTransparent()}

Definition at line 61 of file render_target.h.

kDefaultStencilAttachmentConfig

constexpr AttachmentConfig impeller::RenderTarget::kDefaultStencilAttachmentConfig

staticconstexpr

Initial value:

= {
      .storage_mode = StorageMode::kDeviceTransient,
      .load_action = LoadAction::kClear,
      .store_action = StoreAction::kDontCare,
      .clear_color = Color::BlackTransparent()}

Definition at line 68 of file render_target.h.

---

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

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