#include <render_pass_builder_vk.h>

Public Member Functions
	RenderPassBuilderVK ()

	~RenderPassBuilderVK ()

	RenderPassBuilderVK (const RenderPassBuilderVK &)=delete

RenderPassBuilderVK &	operator= (const RenderPassBuilderVK &)=delete

RenderPassBuilderVK &	SetColorAttachment (size_t index, PixelFormat format, SampleCount sample_count, LoadAction load_action, StoreAction store_action, vk::ImageLayout current_layout=vk::ImageLayout::eUndefined, bool is_swapchain=false)

RenderPassBuilderVK &	SetDepthStencilAttachment (PixelFormat format, SampleCount sample_count, LoadAction load_action, StoreAction store_action)

RenderPassBuilderVK &	SetStencilAttachment (PixelFormat format, SampleCount sample_count, LoadAction load_action, StoreAction store_action)

vk::UniqueRenderPass	Build (const vk::Device &device) const

const std::map< size_t, vk::AttachmentDescription > &	GetColorAttachments () const

const std::map< size_t, vk::AttachmentDescription > &	GetResolves () const

const std::optional< vk::AttachmentDescription > &	GetDepthStencil () const

std::optional< vk::AttachmentDescription >	GetColor0 () const

std::optional< vk::AttachmentDescription >	GetColor0Resolve () const

Detailed Description

Definition at line 21 of file render_pass_builder_vk.h.

Constructor & Destructor Documentation

◆ RenderPassBuilderVK() [1/2]

impeller::RenderPassBuilderVK::RenderPassBuilderVK ( )

default

◆ ~RenderPassBuilderVK()

impeller::RenderPassBuilderVK::~RenderPassBuilderVK ( )

default

◆ RenderPassBuilderVK() [2/2]

impeller::RenderPassBuilderVK::RenderPassBuilderVK ( const RenderPassBuilderVK & )

delete

Member Function Documentation

◆ Build()

vk::UniqueRenderPass impeller::RenderPassBuilderVK::Build ( const vk::Device & device ) const

Definition at line 122 of file render_pass_builder_vk.cc.

                                  {
  // This must be less than `VkPhysicalDeviceLimits::maxColorAttachments` but we
  // are not checking.
  auto color_attachments_count =
      colors_.empty() ? 0u : colors_.rbegin()->first + 1u;
  if (color0_.has_value()) {
    color_attachments_count++;
  }
 
  std::array<vk::AttachmentDescription, kMaxAttachments> attachments;
  std::array<vk::AttachmentReference, kMaxColorAttachments> color_refs;
  std::array<vk::AttachmentReference, kMaxColorAttachments> resolve_refs;
  vk::AttachmentReference depth_stencil_ref = kUnusedAttachmentReference;
  size_t attachments_index = 0;
  size_t color_index = 0;
  size_t resolve_index = 0;
 
  if (color0_.has_value()) {
    vk::AttachmentReference color_ref;
    color_ref.attachment = attachments_index;
    color_ref.layout = vk::ImageLayout::eGeneral;
    color_refs.at(color_index++) = color_ref;
    attachments.at(attachments_index++) = color0_.value();
 
    if (color0_resolve_.has_value()) {
      vk::AttachmentReference resolve_ref;
      resolve_ref.attachment = attachments_index;
      resolve_ref.layout = vk::ImageLayout::eGeneral;
      resolve_refs.at(resolve_index++) = resolve_ref;
      attachments.at(attachments_index++) = color0_resolve_.value();
    } else {
      resolve_refs.at(resolve_index++) = kUnusedAttachmentReference;
    }
  }
 
  for (const auto& color : colors_) {
    vk::AttachmentReference color_ref;
    color_ref.attachment = attachments_index;
    color_ref.layout = vk::ImageLayout::eGeneral;
    color_refs.at(color_index++) = color_ref;
    attachments.at(attachments_index++) = color.second;
 
    if (auto found = resolves_.find(color.first); found != resolves_.end()) {
      vk::AttachmentReference resolve_ref;
      resolve_ref.attachment = attachments_index;
      resolve_ref.layout = vk::ImageLayout::eGeneral;
      resolve_refs.at(resolve_index++) = resolve_ref;
      attachments.at(attachments_index++) = found->second;
    } else {
      resolve_refs.at(resolve_index++) = kUnusedAttachmentReference;
    }
  }
 
  if (depth_stencil_.has_value()) {
    depth_stencil_ref.attachment = attachments_index;
    depth_stencil_ref.layout = vk::ImageLayout::eDepthStencilAttachmentOptimal;
    attachments.at(attachments_index++) = depth_stencil_.value();
  }
 
  vk::SubpassDescription subpass0;
  subpass0.pipelineBindPoint = vk::PipelineBindPoint::eGraphics;
  subpass0.setPInputAttachments(color_refs.data());
  subpass0.setInputAttachmentCount(color_index);
  subpass0.setPColorAttachments(color_refs.data());
  subpass0.setColorAttachmentCount(color_index);
  subpass0.setPResolveAttachments(resolve_refs.data());
 
  subpass0.setPDepthStencilAttachment(&depth_stencil_ref);
 
  vk::SubpassDependency deps[3];
  // Incoming dependency. If the attachments were previously used
  // as attachments for a render pass, or sampled from/transfered to,
  // then these operations must complete before we resolve anything
  // to the onscreen.
  deps[0].srcSubpass = VK_SUBPASS_EXTERNAL;
  deps[0].dstSubpass = 0u;
  deps[0].srcStageMask = vk::PipelineStageFlagBits::eColorAttachmentOutput |
                         vk::PipelineStageFlagBits::eFragmentShader;
  deps[0].srcAccessMask = vk::AccessFlagBits::eShaderRead |
                          vk::AccessFlagBits::eColorAttachmentWrite;
  deps[0].dstStageMask = vk::PipelineStageFlagBits::eColorAttachmentOutput;
  deps[0].dstAccessMask = vk::AccessFlagBits::eColorAttachmentWrite;
  deps[0].dependencyFlags = kSelfDependencyFlags;
 
  // Self dependency for reading back the framebuffer, necessary for
  // programmable blend support / framebuffer fetch.
  deps[1].srcSubpass = 0u;  // first subpass
  deps[1].dstSubpass = 0u;  // to itself
  deps[1].srcStageMask = kSelfDependencySrcStageMask;
  deps[1].srcAccessMask = kSelfDependencySrcAccessMask;
  deps[1].dstStageMask = kSelfDependencyDstStageMask;
  deps[1].dstAccessMask = kSelfDependencyDstAccessMask;
  deps[1].dependencyFlags = kSelfDependencyFlags;
 
  // Outgoing dependency. The resolve step or color attachment must complete
  // before we can sample from the image. This dependency is ignored for the
  // onscreen as we will already insert a barrier before presenting the
  // swapchain.
  deps[2].srcSubpass = 0u;  // first subpass
  deps[2].dstSubpass = VK_SUBPASS_EXTERNAL;
  deps[2].srcStageMask = vk::PipelineStageFlagBits::eColorAttachmentOutput;
  deps[2].srcAccessMask = vk::AccessFlagBits::eColorAttachmentWrite;
  deps[2].dstStageMask = vk::PipelineStageFlagBits::eFragmentShader;
  deps[2].dstAccessMask = vk::AccessFlagBits::eShaderRead;
  deps[2].dependencyFlags = kSelfDependencyFlags;
 
  vk::RenderPassCreateInfo render_pass_desc;
  render_pass_desc.setPAttachments(attachments.data());
  render_pass_desc.setAttachmentCount(attachments_index);
  render_pass_desc.setSubpasses(subpass0);
  render_pass_desc.setPDependencies(deps);
  render_pass_desc.setDependencyCount(3);
 
  auto [result, pass] = device.createRenderPassUnique(render_pass_desc);
  if (result != vk::Result::eSuccess) {
    VALIDATION_LOG << "Failed to create render pass: " << vk::to_string(result);
    return {};
  }
  return std::move(pass);
}

References device, impeller::kSelfDependencyDstAccessMask, impeller::kSelfDependencyDstStageMask, impeller::kSelfDependencyFlags, impeller::kSelfDependencySrcAccessMask, impeller::kSelfDependencySrcStageMask, impeller::kUnusedAttachmentReference, and VALIDATION_LOG.

Referenced by impeller::CreateCompatRenderPassForPipeline(), impeller::ContextVK::InitializeCommonlyUsedShadersIfNeeded(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), and impeller::testing::TEST().

◆ GetColor0()

std::optional< vk::AttachmentDescription > impeller::RenderPassBuilderVK::GetColor0 ( ) const

Definition at line 290 of file render_pass_builder_vk.cc.

          {
  return color0_;
}

Referenced by impeller::testing::TEST(), impeller::testing::TEST(), and impeller::testing::TEST().

◆ GetColor0Resolve()

std::optional< vk::AttachmentDescription > impeller::RenderPassBuilderVK::GetColor0Resolve ( ) const

Definition at line 296 of file render_pass_builder_vk.cc.

          {
  return color0_resolve_;
}

Referenced by impeller::testing::TEST().

◆ GetColorAttachments()

const std::map< size_t, vk::AttachmentDescription > & impeller::RenderPassBuilderVK::GetColorAttachments ( ) const

Definition at line 275 of file render_pass_builder_vk.cc.

                                               {
  return colors_;
}

◆ GetDepthStencil()

const std::optional< vk::AttachmentDescription > & impeller::RenderPassBuilderVK::GetDepthStencil ( ) const

Definition at line 285 of file render_pass_builder_vk.cc.

                                           {
  return depth_stencil_;
}

Referenced by impeller::testing::TEST(), impeller::testing::TEST(), and impeller::testing::TEST().

◆ GetResolves()

const std::map< size_t, vk::AttachmentDescription > & impeller::RenderPassBuilderVK::GetResolves ( ) const

Definition at line 280 of file render_pass_builder_vk.cc.

                                       {
  return resolves_;
}

◆ operator=()

RenderPassBuilderVK & impeller::RenderPassBuilderVK::operator= ( const RenderPassBuilderVK & )

delete

◆ SetColorAttachment()

RenderPassBuilderVK & impeller::RenderPassBuilderVK::SetColorAttachment	(	size_t	index,
		PixelFormat	format,
		SampleCount	sample_count,
		LoadAction	load_action,
		StoreAction	store_action,
		vk::ImageLayout	current_layout = `vk::ImageLayout::eUndefined`,
		bool	is_swapchain = `false`
	)

Definition at line 38 of file render_pass_builder_vk.cc.

                       {
  vk::AttachmentDescription desc;
  desc.format = ToVKImageFormat(format);
  desc.samples = ToVKSampleCount(sample_count);
  desc.loadOp = ToVKAttachmentLoadOp(load_action);
  desc.storeOp = ToVKAttachmentStoreOp(store_action, false);
  desc.stencilLoadOp = vk::AttachmentLoadOp::eDontCare;
  desc.stencilStoreOp = vk::AttachmentStoreOp::eDontCare;
  if (load_action == LoadAction::kLoad) {
    desc.initialLayout = current_layout;
  } else {
    desc.initialLayout = vk::ImageLayout::eUndefined;
  }
  desc.finalLayout = ComputeFinalLayout(is_swapchain, sample_count);
 
  const bool performs_resolves = StoreActionPerformsResolve(store_action);
  if (index == 0u) {
    color0_ = desc;
 
    if (performs_resolves) {
      desc.storeOp = ToVKAttachmentStoreOp(store_action, true);
      desc.samples = vk::SampleCountFlagBits::e1;
      desc.finalLayout = ComputeFinalLayout(is_swapchain, SampleCount::kCount1);
      color0_resolve_ = desc;
    } else {
      color0_resolve_ = std::nullopt;
    }
  } else {
    colors_[index] = desc;
    if (performs_resolves) {
      desc.storeOp = ToVKAttachmentStoreOp(store_action, true);
      desc.samples = vk::SampleCountFlagBits::e1;
      desc.finalLayout = ComputeFinalLayout(is_swapchain, SampleCount::kCount1);
      resolves_[index] = desc;
    } else {
      resolves_.erase(index);
    }
  }
  return *this;
}

References format, impeller::kCount1, impeller::kLoad, impeller::StoreActionPerformsResolve(), impeller::ToVKAttachmentLoadOp(), impeller::ToVKAttachmentStoreOp(), impeller::ToVKImageFormat(), and impeller::ToVKSampleCount().