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 278 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 347 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(), image, swapchain, VALIDATION_LOG, and impeller::SurfaceVK::WrapSwapchainImage().

◆ AddFinalCommandBuffer()

void impeller::KHRSwapchainImplVK::AddFinalCommandBuffer ( std::shared_ptr< CommandBuffer > cmd_buffer )

Definition at line 420 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 111 of file khr_swapchain_impl_vk.cc.

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

References surface.

◆ DestroySwapchain()

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

Definition at line 330 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 343 of file khr_swapchain_impl_vk.cc.

                                                            {
  return context_.lock();
}

◆ GetCurrentUnderlyingSurfaceSize()

std::optional< ISize > impeller::KHRSwapchainImplVK::GetCurrentUnderlyingSurfaceSize ( ) const

Definition at line 286 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 282 of file khr_swapchain_impl_vk.cc.

                                               {
  return size_;
}

◆ GetSurfaceFormat()

vk::Format impeller::KHRSwapchainImplVK::GetSurfaceFormat ( ) const

Definition at line 339 of file khr_swapchain_impl_vk.cc.

                                                    {
  return surface_format_;
}

◆ IsValid()

bool impeller::KHRSwapchainImplVK::IsValid ( ) const

Definition at line 318 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

Classes

Public Member Functions

Static Public Member Functions