impeller::KHRSwapchainImplVK Class Reference

An instance of a swapchain that does NOT adapt to going out of date with the underlying surface. Errors will be indicated when the next drawable is acquired from this implementation of the swapchain. If the error is due the swapchain going out of date, the caller must recreate another instance by optionally stealing this implementations guts. More...

#include <khr_swapchain_impl_vk.h>

Inheritance diagram for impeller::KHRSwapchainImplVK:

Classes
struct	AcquireResult

Public Member Functions
	~KHRSwapchainImplVK ()
bool	IsValid () const
AcquireResult	AcquireNextDrawable ()
vk::Format	GetSurfaceFormat () const
std::shared_ptr< Context >	GetContext () const
std::pair< vk::UniqueSurfaceKHR, vk::UniqueSwapchainKHR >	DestroySwapchain ()
const ISize &	GetSize () const
void	AddFinalCommandBuffer (std::shared_ptr< CommandBuffer > cmd_buffer)
std::optional< ISize >	GetCurrentUnderlyingSurfaceSize () const

Static Public Member Functions
static std::shared_ptr< KHRSwapchainImplVK >	Create (const std::shared_ptr< Context > &context, vk::UniqueSurfaceKHR surface, const ISize &size, bool enable_msaa=true, vk::SwapchainKHR old_swapchain=VK_NULL_HANDLE)

Detailed Description

An instance of a swapchain that does NOT adapt to going out of date with the underlying surface. Errors will be indicated when the next drawable is acquired from this implementation of the swapchain. If the error is due the swapchain going out of date, the caller must recreate another instance by optionally stealing this implementations guts.

Definition at line 30 of file khr_swapchain_impl_vk.h.

Constructor & Destructor Documentation

~KHRSwapchainImplVK()

impeller::KHRSwapchainImplVK::~KHRSwapchainImplVK

(

)

Definition at line 273 of file khr_swapchain_impl_vk.cc.

                                        {
  DestroySwapchain();
}

References DestroySwapchain().

Member Function Documentation

AcquireNextDrawable()

KHRSwapchainImplVK::AcquireResult impeller::KHRSwapchainImplVK::AcquireNextDrawable

(

)

Wait on the host for the synchronizer fence.

Get the next image index.

Record all subsequent cmd buffers as part of the current frame.

Definition at line 342 of file khr_swapchain_impl_vk.cc.

                                                                        {
  auto context_strong = context_.lock();
  if (!context_strong) {
    return KHRSwapchainImplVK::AcquireResult{};
  }
 
  const auto& context = ContextVK::Cast(*context_strong);
 
  current_frame_ = (current_frame_ + 1u) % synchronizers_.size();
 
  const auto& sync = synchronizers_[current_frame_];
 
  //----------------------------------------------------------------------------
  /// Wait on the host for the synchronizer fence.
  ///
  if (!sync->WaitForFence(context.GetDevice())) {
    VALIDATION_LOG << "Could not wait for fence.";
    return KHRSwapchainImplVK::AcquireResult{};
  }
 
  //----------------------------------------------------------------------------
  /// Get the next image index.
  ///
  /// @bug  Non-infinite timeouts are not supported on some older Android
  ///       devices and the only indication we get is log spam which serves to
  ///       add confusion. Just use an infinite timeout instead of being
  ///       defensive.
  auto [acq_result, index] = context.GetDevice().acquireNextImageKHR(
      *swapchain_,                           // swapchain
      std::numeric_limits<uint64_t>::max(),  // timeout (ns)
      *sync->render_ready,                   // signal semaphore
      nullptr                                // fence
  );
 
  switch (acq_result) {
    case vk::Result::eSuccess:
      // Keep going.
      break;
    case vk::Result::eSuboptimalKHR:
    case vk::Result::eErrorOutOfDateKHR:
      // A recoverable error. Just say we are out of date.
      return AcquireResult{true /* out of date */};
      break;
    default:
      // An unrecoverable error.
      VALIDATION_LOG << "Could not acquire next swapchain image: "
                     << vk::to_string(acq_result);
      return AcquireResult{false /* out of date */};
  }
 
  if (index >= images_.size()) {
    VALIDATION_LOG << "Swapchain returned an invalid image index.";
    return KHRSwapchainImplVK::AcquireResult{};
  }
 
  /// Record all subsequent cmd buffers as part of the current frame.
  context.GetGPUTracer()->MarkFrameStart();
 
  auto image = images_[index % images_.size()];
  uint32_t image_index = index;
  return AcquireResult{SurfaceVK::WrapSwapchainImage(
      transients_,  // transients
      image,        // swapchain image
      [weak_swapchain = weak_from_this(), image, image_index]() -> bool {
        auto swapchain = weak_swapchain.lock();
        if (!swapchain) {
          return false;
        }
        return swapchain->Present(image, image_index);
      }  // swap callback
      )};
}

References impeller::BackendCast< ContextVK, Context >::Cast(), VALIDATION_LOG, and impeller::SurfaceVK::WrapSwapchainImage().

AddFinalCommandBuffer()

void impeller::KHRSwapchainImplVK::AddFinalCommandBuffer

(

std::shared_ptr< CommandBuffer >

cmd_buffer

)

Definition at line 415 of file khr_swapchain_impl_vk.cc.

                                             {
  const auto& sync = synchronizers_[current_frame_];
  sync->final_cmd_buffer = std::move(cmd_buffer);
  sync->has_onscreen = true;
}

Create()

std::shared_ptr< KHRSwapchainImplVK > impeller::KHRSwapchainImplVK::Create ( const std::shared_ptr< Context > &  context, vk::UniqueSurfaceKHR  surface, const ISize &  size, bool  enable_msaa = true, vk::SwapchainKHR  old_swapchain = VK_NULL_HANDLE  )

static

Definition at line 115 of file khr_swapchain_impl_vk.cc.

                                  {
  return std::shared_ptr<KHRSwapchainImplVK>(new KHRSwapchainImplVK(
      context, std::move(surface), size, enable_msaa, old_swapchain));
}

DestroySwapchain()

std::pair< vk::UniqueSurfaceKHR, vk::UniqueSwapchainKHR > impeller::KHRSwapchainImplVK::DestroySwapchain

(

)

Definition at line 325 of file khr_swapchain_impl_vk.cc.

                                     {
  WaitIdle();
  is_valid_ = false;
  synchronizers_.clear();
  images_.clear();
  context_.reset();
  return {std::move(surface_), std::move(swapchain_)};
}

Referenced by ~KHRSwapchainImplVK().

GetContext()

std::shared_ptr< Context > impeller::KHRSwapchainImplVK::GetContext

(

)

const

Definition at line 338 of file khr_swapchain_impl_vk.cc.

                                                            {
  return context_.lock();
}

GetCurrentUnderlyingSurfaceSize()

std::optional< ISize > impeller::KHRSwapchainImplVK::GetCurrentUnderlyingSurfaceSize

(

)

const

Definition at line 281 of file khr_swapchain_impl_vk.cc.

          {
  if (!IsValid()) {
    return std::nullopt;
  }
 
  auto context = context_.lock();
  if (!context) {
    return std::nullopt;
  }
 
  auto& vk_context = ContextVK::Cast(*context);
  const auto [result, surface_caps] =
      vk_context.GetPhysicalDevice().getSurfaceCapabilitiesKHR(surface_.get());
  if (result != vk::Result::eSuccess) {
    return std::nullopt;
  }
 
  // From the spec: `currentExtent` is the current width and height of the
  // surface, or the special value (0xFFFFFFFF, 0xFFFFFFFF) indicating that the
  // surface size will be determined by the extent of a swapchain targeting the
  // surface.
  constexpr uint32_t kCurrentExtentsPlaceholder = 0xFFFFFFFF;
  if (surface_caps.currentExtent.width == kCurrentExtentsPlaceholder ||
      surface_caps.currentExtent.height == kCurrentExtentsPlaceholder) {
    return std::nullopt;
  }
 
  return ISize::MakeWH(surface_caps.currentExtent.width,
                       surface_caps.currentExtent.height);
}

References impeller::BackendCast< ContextVK, Context >::Cast(), IsValid(), and impeller::TSize< T >::MakeWH().

GetSize()

const ISize & impeller::KHRSwapchainImplVK::GetSize

(

)

const

Definition at line 277 of file khr_swapchain_impl_vk.cc.

                                               {
  return size_;
}

GetSurfaceFormat()

vk::Format impeller::KHRSwapchainImplVK::GetSurfaceFormat

(

)

const

Definition at line 334 of file khr_swapchain_impl_vk.cc.

                                                    {
  return surface_format_;
}

IsValid()

bool impeller::KHRSwapchainImplVK::IsValid

(

)

const

Definition at line 313 of file khr_swapchain_impl_vk.cc.

                                       {
  return is_valid_;
}

Referenced by GetCurrentUnderlyingSurfaceSize().

---

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

• impeller/renderer/backend/vulkan/swapchain/khr/khr_swapchain_impl_vk.h
• impeller/renderer/backend/vulkan/swapchain/khr/khr_swapchain_impl_vk.cc