7 #include "fml/synchronization/semaphore.h"
33 auto acquire_res = device.createFenceUnique(
34 vk::FenceCreateInfo{vk::FenceCreateFlagBits::eSignaled});
35 auto render_res = device.createSemaphoreUnique({});
36 auto present_res = device.createSemaphoreUnique({});
37 if (acquire_res.result != vk::Result::eSuccess ||
38 render_res.result != vk::Result::eSuccess ||
39 present_res.result != vk::Result::eSuccess) {
43 acquire = std::move(acquire_res.value);
52 if (
auto result = device.waitForFences(
55 std::numeric_limits<uint64_t>::max()
57 result != vk::Result::eSuccess) {
61 if (
auto result = device.resetFences(*
acquire);
62 result != vk::Result::eSuccess) {
63 VALIDATION_LOG <<
"Could not reset fence: " << vk::to_string(result);
71 vk::SurfaceFormatKHR format) {
72 return std::find(formats.begin(), formats.end(), format) != formats.end();
76 const std::vector<vk::SurfaceFormatKHR>& formats,
78 const auto colorspace = vk::ColorSpaceKHR::eSrgbNonlinear;
79 const auto vk_preference =
85 std::vector<vk::SurfaceFormatKHR> options = {
86 {vk::Format::eB8G8R8A8Unorm, colorspace},
87 {vk::Format::eR8G8B8A8Unorm, colorspace}};
88 for (
const auto& format : options) {
98 vk::CompositeAlphaFlagsKHR flags) {
99 if (flags & vk::CompositeAlphaFlagBitsKHR::eInherit) {
100 return vk::CompositeAlphaFlagBitsKHR::eInherit;
102 if (flags & vk::CompositeAlphaFlagBitsKHR::ePreMultiplied) {
103 return vk::CompositeAlphaFlagBitsKHR::ePreMultiplied;
105 if (flags & vk::CompositeAlphaFlagBitsKHR::ePostMultiplied) {
106 return vk::CompositeAlphaFlagBitsKHR::ePostMultiplied;
108 if (flags & vk::CompositeAlphaFlagBitsKHR::eOpaque) {
109 return vk::CompositeAlphaFlagBitsKHR::eOpaque;
116 const std::shared_ptr<Context>& context,
117 vk::UniqueSurfaceKHR surface,
120 vk::SwapchainKHR old_swapchain) {
122 context, std::move(surface), size, enable_msaa, old_swapchain));
125 KHRSwapchainImplVK::KHRSwapchainImplVK(
const std::shared_ptr<Context>& context,
126 vk::UniqueSurfaceKHR surface,
129 vk::SwapchainKHR old_swapchain) {
137 const auto [caps_result, surface_caps] =
138 vk_context.GetPhysicalDevice().getSurfaceCapabilitiesKHR(*surface);
139 if (caps_result != vk::Result::eSuccess) {
141 << vk::to_string(caps_result);
145 auto [formats_result, formats] =
146 vk_context.GetPhysicalDevice().getSurfaceFormatsKHR(*surface);
147 if (formats_result != vk::Result::eSuccess) {
149 << vk::to_string(formats_result);
154 formats, vk_context.GetCapabilities()->GetDefaultColorFormat());
155 if (!format.has_value()) {
159 vk_context.SetOffscreenFormat(
ToPixelFormat(format.value().format));
161 const auto composite =
163 if (!composite.has_value()) {
168 vk::SwapchainCreateInfoKHR swapchain_info;
169 swapchain_info.surface = *surface;
170 swapchain_info.imageFormat = format.value().format;
171 swapchain_info.imageColorSpace = format.value().colorSpace;
172 swapchain_info.presentMode = vk::PresentModeKHR::eFifo;
173 swapchain_info.imageExtent = vk::Extent2D{
174 std::clamp(
static_cast<uint32_t
>(size.
width),
175 surface_caps.minImageExtent.width,
176 surface_caps.maxImageExtent.width),
177 std::clamp(
static_cast<uint32_t
>(size.
height),
178 surface_caps.minImageExtent.height,
179 surface_caps.maxImageExtent.height),
181 swapchain_info.minImageCount =
182 std::clamp(surface_caps.minImageCount + 1u,
183 surface_caps.minImageCount,
184 surface_caps.maxImageCount == 0u
185 ? surface_caps.minImageCount + 1u
186 : surface_caps.maxImageCount
188 swapchain_info.imageArrayLayers = 1u;
191 swapchain_info.imageUsage = vk::ImageUsageFlagBits::eColorAttachment |
192 vk::ImageUsageFlagBits::eInputAttachment;
193 swapchain_info.preTransform = vk::SurfaceTransformFlagBitsKHR::eIdentity;
194 swapchain_info.compositeAlpha = composite.value();
198 swapchain_info.clipped =
true;
201 swapchain_info.imageSharingMode = vk::SharingMode::eExclusive;
202 swapchain_info.oldSwapchain = old_swapchain;
204 auto [swapchain_result, swapchain] =
205 vk_context.GetDevice().createSwapchainKHRUnique(swapchain_info);
206 if (swapchain_result != vk::Result::eSuccess) {
208 << vk::to_string(swapchain_result);
212 auto [images_result, images] =
213 vk_context.GetDevice().getSwapchainImagesKHR(*swapchain);
214 if (images_result != vk::Result::eSuccess) {
219 TextureDescriptor texture_desc;
222 texture_desc.format =
ToPixelFormat(swapchain_info.imageFormat);
223 texture_desc.size =
ISize::MakeWH(swapchain_info.imageExtent.width,
224 swapchain_info.imageExtent.height);
226 std::vector<std::shared_ptr<KHRSwapchainImageVK>> swapchain_images;
227 for (
const auto& image : images) {
228 auto swapchain_image = std::make_shared<KHRSwapchainImageVK>(
230 vk_context.GetDevice(),
233 if (!swapchain_image->IsValid()) {
238 vk_context.GetDevice(), swapchain_image->GetImage(),
239 "SwapchainImage" + std::to_string(swapchain_images.size()));
241 vk_context.GetDevice(), swapchain_image->GetImageView(),
242 "SwapchainImageView" + std::to_string(swapchain_images.size()));
244 swapchain_images.emplace_back(swapchain_image);
247 std::vector<std::unique_ptr<KHRFrameSynchronizerVK>> synchronizers;
250 std::make_unique<KHRFrameSynchronizerVK>(vk_context.GetDevice());
251 if (!sync->is_valid) {
255 synchronizers.emplace_back(std::move(sync));
257 FML_DCHECK(!synchronizers.empty());
260 surface_ = std::move(surface);
261 surface_format_ = swapchain_info.imageFormat;
262 swapchain_ = std::move(swapchain);
263 transients_ = std::make_shared<SwapchainTransientsVK>(context, texture_desc,
265 images_ = std::move(swapchain_images);
266 synchronizers_ = std::move(synchronizers);
267 current_frame_ = synchronizers_.size() - 1u;
269 enable_msaa_ = enable_msaa;
287 auto context = context_.lock();
293 const auto [result, surface_caps] =
294 vk_context.GetPhysicalDevice().getSurfaceCapabilitiesKHR(surface_.get());
295 if (result != vk::Result::eSuccess) {
303 constexpr uint32_t kCurrentExtentsPlaceholder = 0xFFFFFFFF;
304 if (surface_caps.currentExtent.width == kCurrentExtentsPlaceholder ||
305 surface_caps.currentExtent.height == kCurrentExtentsPlaceholder) {
310 surface_caps.currentExtent.height);
317 void KHRSwapchainImplVK::WaitIdle()
const {
318 if (
auto context = context_.lock()) {
319 [[maybe_unused]]
auto result =
324 std::pair<vk::UniqueSurfaceKHR, vk::UniqueSwapchainKHR>
328 synchronizers_.clear();
331 return {std::move(surface_), std::move(swapchain_)};
335 return surface_format_;
339 return context_.lock();
343 auto context_strong = context_.lock();
344 if (!context_strong) {
350 current_frame_ = (current_frame_ + 1u) % synchronizers_.size();
352 const auto& sync = synchronizers_[current_frame_];
357 if (!sync->WaitForFence(context.GetDevice())) {
369 auto [acq_result, index] = context.GetDevice().acquireNextImageKHR(
371 std::numeric_limits<uint64_t>::max(),
376 switch (acq_result) {
377 case vk::Result::eSuccess:
380 case vk::Result::eSuboptimalKHR:
381 case vk::Result::eErrorOutOfDateKHR:
388 << vk::to_string(acq_result);
392 if (index >= images_.size()) {
398 context.GetGPUTracer()->MarkFrameStart();
400 auto image = images_[index % images_.size()];
401 uint32_t image_index = index;
405 [weak_swapchain = weak_from_this(), image, image_index]() ->
bool {
406 auto swapchain = weak_swapchain.lock();
410 return swapchain->Present(image, image_index);
416 std::shared_ptr<CommandBuffer> cmd_buffer) {
417 const auto& sync = synchronizers_[current_frame_];
418 sync->final_cmd_buffer = std::move(cmd_buffer);
419 sync->has_onscreen =
true;
422 bool KHRSwapchainImplVK::Present(
423 const std::shared_ptr<KHRSwapchainImageVK>& image,
425 auto context_strong = context_.lock();
426 if (!context_strong) {
431 const auto& sync = synchronizers_[current_frame_];
432 context.GetGPUTracer()->MarkFrameEnd();
437 if (!sync->has_onscreen) {
438 sync->final_cmd_buffer = context.CreateCommandBuffer();
440 sync->has_onscreen =
false;
441 if (!sync->final_cmd_buffer) {
445 auto vk_final_cmd_buffer =
449 barrier.new_layout = vk::ImageLayout::ePresentSrcKHR;
450 barrier.cmd_buffer = vk_final_cmd_buffer;
451 barrier.src_access = vk::AccessFlagBits::eColorAttachmentWrite;
452 barrier.src_stage = vk::PipelineStageFlagBits::eColorAttachmentOutput;
453 barrier.dst_access = {};
454 barrier.dst_stage = vk::PipelineStageFlagBits::eBottomOfPipe;
456 if (!image->SetLayout(barrier).ok()) {
460 if (vk_final_cmd_buffer.end() != vk::Result::eSuccess) {
469 vk::SubmitInfo submit_info;
470 vk::PipelineStageFlags wait_stage =
471 vk::PipelineStageFlagBits::eColorAttachmentOutput;
472 submit_info.setWaitDstStageMask(wait_stage);
473 submit_info.setWaitSemaphores(*sync->render_ready);
474 submit_info.setSignalSemaphores(*sync->present_ready);
475 submit_info.setCommandBuffers(vk_final_cmd_buffer);
477 context.GetGraphicsQueue()->Submit(submit_info, *sync->acquire);
478 if (result != vk::Result::eSuccess) {
480 << vk::to_string(result);
488 uint32_t indices[] = {
static_cast<uint32_t
>(index)};
490 vk::PresentInfoKHR present_info;
491 present_info.setSwapchains(*swapchain_);
492 present_info.setImageIndices(indices);
493 present_info.setWaitSemaphores(*sync->present_ready);
495 auto result = context.GetGraphicsQueue()->Present(present_info);
498 case vk::Result::eErrorOutOfDateKHR:
501 case vk::Result::eErrorSurfaceLostKHR:
505 case vk::Result::eSuboptimalKHR:
511 case vk::Result::eSuccess:
514 VALIDATION_LOG <<
"Could not present queue: " << vk::to_string(result);
static ContextVK & Cast(Context &base)
vk::CommandBuffer GetCommandBuffer() const
Retrieve the native command buffer from this object.
bool SetDebugName(T handle, std::string_view label) const
const vk::Device & GetDevice() const
An instance of a swapchain that does NOT adapt to going out of date with the underlying surface....
std::shared_ptr< Context > GetContext() const
void AddFinalCommandBuffer(std::shared_ptr< CommandBuffer > cmd_buffer)
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)
AcquireResult AcquireNextDrawable()
vk::Format GetSurfaceFormat() const
std::optional< ISize > GetCurrentUnderlyingSurfaceSize() const
std::pair< vk::UniqueSurfaceKHR, vk::UniqueSwapchainKHR > DestroySwapchain()
const ISize & GetSize() const
static std::unique_ptr< SurfaceVK > WrapSwapchainImage(const std::shared_ptr< SwapchainTransientsVK > &transients, const std::shared_ptr< TextureSourceVK > &swapchain_image, SwapCallback swap_callback)
Wrap the swapchain image in a Surface, which provides the additional configuration required for usage...
constexpr PixelFormat ToPixelFormat(vk::Format format)
static std::optional< vk::SurfaceFormatKHR > ChooseSurfaceFormat(const std::vector< vk::SurfaceFormatKHR > &formats, PixelFormat preference)
static constexpr size_t kMaxFramesInFlight
static bool ContainsFormat(const std::vector< vk::SurfaceFormatKHR > &formats, vk::SurfaceFormatKHR format)
PixelFormat
The Pixel formats supported by Impeller. The naming convention denotes the usage of the component,...
constexpr vk::Format ToVKImageFormat(PixelFormat format)
static std::optional< vk::CompositeAlphaFlagBitsKHR > ChooseAlphaCompositionMode(vk::CompositeAlphaFlagsKHR flags)
vk::UniqueSemaphore render_ready
bool WaitForFence(const vk::Device &device)
KHRFrameSynchronizerVK(const vk::Device &device)
~KHRFrameSynchronizerVK()=default
vk::UniqueSemaphore present_ready
std::shared_ptr< CommandBuffer > final_cmd_buffer
static constexpr TSize MakeWH(Type width, Type height)