encounter
/
dawn-cmake
mirror of https://github.com/encounter/dawn-cmake.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Initial new swapchains on Vulkan. 

Bug: dawn:269

Change-Id: I5b7a4edfa876d5a64f8f135adb619be021e4f534
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/17966
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Austin Eng <enga@chromium.org>
This commit is contained in:
Corentin Wallez 2020-10-17 23:31:37 +00:00 committed by Commit Bot service account
parent 875091308b
commit 47a6a94e15
4 changed files with 392 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
examples/SampleUtils.cpp
View File

@ -96,6 +96,7 @@ wgpu::Device CreateCppDawnDevice() {
// Create the test window and discover adapters using it (esp. for OpenGL)
utils::SetupGLFWWindowHintsForBackend(backendType);
glfwWindowHint(GLFW_COCOA_RETINA_FRAMEBUFFER, GLFW_FALSE);
window = glfwCreateWindow(640, 480, "Dawn window", nullptr, nullptr);
if (!window) {
return wgpu::Device();

4
src/dawn_native/vulkan/DeviceVk.cpp
View File

@ -141,13 +141,13 @@ namespace dawn_native { namespace vulkan {
}
ResultOrError<SwapChainBase*> Device::CreateSwapChainImpl(
const SwapChainDescriptor* descriptor) {
return SwapChain::Create(this, descriptor);
return OldSwapChain::Create(this, descriptor);
}
ResultOrError<NewSwapChainBase*> Device::CreateSwapChainImpl(
Surface* surface,
NewSwapChainBase* previousSwapChain,
const SwapChainDescriptor* descriptor) {
return DAWN_VALIDATION_ERROR("New swapchains not implemented.");
return SwapChain::Create(this, surface, previousSwapChain, descriptor);
}
ResultOrError<Ref<TextureBase>> Device::CreateTextureImpl(const TextureDescriptor* descriptor) {
return Texture::Create(this, descriptor);

350
src/dawn_native/vulkan/SwapChainVk.cpp
View File

@ -14,17 +14,24 @@
#include "dawn_native/vulkan/SwapChainVk.h"
#include "dawn_native/Surface.h"
#include "dawn_native/vulkan/AdapterVk.h"
#include "dawn_native/vulkan/BackendVk.h"
#include "dawn_native/vulkan/DeviceVk.h"
#include "dawn_native/vulkan/FencedDeleter.h"
#include "dawn_native/vulkan/TextureVk.h"
#include "dawn_native/vulkan/VulkanError.h"
namespace dawn_native { namespace vulkan {
// OldSwapChain
// static
SwapChain* SwapChain::Create(Device* device, const SwapChainDescriptor* descriptor) {
return new SwapChain(device, descriptor);
OldSwapChain* OldSwapChain::Create(Device* device, const SwapChainDescriptor* descriptor) {
return new OldSwapChain(device, descriptor);
}
SwapChain::SwapChain(Device* device, const SwapChainDescriptor* descriptor)
OldSwapChain::OldSwapChain(Device* device, const SwapChainDescriptor* descriptor)
: OldSwapChainBase(device, descriptor) {
const auto& im = GetImplementation();
DawnWSIContextVulkan wsiContext = {};
@ -34,10 +41,10 @@ namespace dawn_native { namespace vulkan {
mTextureUsage = static_cast<wgpu::TextureUsage>(im.textureUsage);
}
SwapChain::~SwapChain() {
OldSwapChain::~OldSwapChain() {
}
TextureBase* SwapChain::GetNextTextureImpl(const TextureDescriptor* descriptor) {
TextureBase* OldSwapChain::GetNextTextureImpl(const TextureDescriptor* descriptor) {
const auto& im = GetImplementation();
DawnSwapChainNextTexture next = {};
DawnSwapChainError error = im.GetNextTexture(im.userData, &next);
@ -53,7 +60,7 @@ namespace dawn_native { namespace vulkan {
.Detach();
}
MaybeError SwapChain::OnBeforePresent(TextureViewBase* view) {
MaybeError OldSwapChain::OnBeforePresent(TextureViewBase* view) {
Device* device = ToBackend(GetDevice());
// Perform the necessary pipeline barriers for the texture to be used with the usage
@ -67,4 +74,335 @@ namespace dawn_native { namespace vulkan {
return {};
}
// SwapChain
namespace {
ResultOrError<VkSurfaceKHR> CreateVulkanSurface(Backend* backend, Surface* surface) {
const VulkanGlobalInfo& info = backend->GetGlobalInfo();
const VulkanFunctions& fn = backend->GetFunctions();
VkInstance instance = backend->GetVkInstance();
switch (surface->GetType()) {
#if defined(DAWN_ENABLE_BACKEND_METAL)
case Surface::Type::MetalLayer:
if (info.HasExt(InstanceExt::MetalSurface)) {
VkMetalSurfaceCreateInfoEXT createInfo;
createInfo.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
createInfo.pNext = nullptr;
createInfo.flags = 0;
createInfo.pLayer = surface->GetMetalLayer();
VkSurfaceKHR vkSurface = VK_NULL_HANDLE;
DAWN_TRY(CheckVkSuccess(
fn.CreateMetalSurfaceEXT(instance, &createInfo, nullptr, &*vkSurface),
"CreateMetalSurface"));
return vkSurface;
}
break;
#endif // defined(DAWN_ENABLE_BACKEND_METAL)
#if defined(DAWN_PLATFORM_WINDOWS)
case Surface::Type::WindowsHWND:
if (info.HasExt(InstanceExt::Win32Surface)) {
VkWin32SurfaceCreateInfoKHR createInfo;
createInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
createInfo.pNext = nullptr;
createInfo.flags = 0;
createInfo.hinstance = static_cast<HINSTANCE>(surface->GetHInstance());
createInfo.hwnd = static_cast<HWND>(surface->GetHWND());
VkSurfaceKHR vkSurface = VK_NULL_HANDLE;
DAWN_TRY(CheckVkSuccess(
fn.CreateWin32SurfaceKHR(instance, &createInfo, nullptr, &*vkSurface),
"CreateWin32Surface"));
return vkSurface;
}
break;
#endif // defined(DAWN_PLATFORM_WINDOWS)
#if defined(DAWN_USE_X11)
case Surface::Type::Xlib:
if (info.HasExt(InstanceExt::XlibSurface)) {
VkXlibSurfaceCreateInfoKHR createInfo;
createInfo.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
createInfo.pNext = nullptr;
createInfo.flags = 0;
createInfo.dpy = static_cast<Display*>(surface->GetXDisplay());
createInfo.window = surface->GetXWindow();
VkSurfaceKHR vkSurface = VK_NULL_HANDLE;
DAWN_TRY(CheckVkSuccess(
fn.CreateXlibSurfaceKHR(instance, &createInfo, nullptr, &*vkSurface),
"CreateWin32Surface"));
return vkSurface;
}
break;
#endif // defined(DAWN_USE_X11)
default:
break;
}
return DAWN_VALIDATION_ERROR("Unsupported surface type for Vulkan");
}
VkPresentModeKHR ToVulkanPresentMode(wgpu::PresentMode mode) {
switch (mode) {
case wgpu::PresentMode::Fifo:
return VK_PRESENT_MODE_FIFO_KHR;
case wgpu::PresentMode::Immediate:
return VK_PRESENT_MODE_IMMEDIATE_KHR;
case wgpu::PresentMode::Mailbox:
return VK_PRESENT_MODE_MAILBOX_KHR;
}
}
} // anonymous namespace
// static
ResultOrError<SwapChain*> SwapChain::Create(Device* device,
Surface* surface,
NewSwapChainBase* previousSwapChain,
const SwapChainDescriptor* descriptor) {
std::unique_ptr<SwapChain> swapchain =
std::make_unique<SwapChain>(device, surface, descriptor);
DAWN_TRY(swapchain->Initialize(previousSwapChain));
return swapchain.release();
}
SwapChain::~SwapChain() {
DetachFromSurface();
}
MaybeError SwapChain::Initialize(NewSwapChainBase* previousSwapChain) {
Device* device = ToBackend(GetDevice());
Adapter* adapter = ToBackend(GetDevice()->GetAdapter());
VkSwapchainKHR oldVkSwapChain = VK_NULL_HANDLE;
if (previousSwapChain != nullptr) {
// TODO(cwallez@chromium.org): The first time a surface is used with a Device, check
// it is supported with vkGetPhysicalDeviceSurfaceSupportKHR.
// TODO(cwallez@chromium.org): figure out what should happen when surfaces are used by
// multiple backends one after the other. It probably needs to block until the backend
// and GPU are completely finished with the previous swapchain.
ASSERT(previousSwapChain->GetBackendType() == wgpu::BackendType::Vulkan);
// The previous swapchain is a dawn_native::vulkan::SwapChain so we can reuse its
// VkSurfaceKHR provided they are on the same instance.
// TODO(cwallez@chromium.org): check they are the same instance.
// TODO(cwallez@chromium.org): use ToBackend once OldSwapChainBase is removed.
SwapChain* previousVulkanSwapChain = static_cast<SwapChain*>(previousSwapChain);
std::swap(previousVulkanSwapChain->mVkSurface, mVkSurface);
// TODO(cwallez@chromium.org): Figure out switching a single surface between multiple
// Vulkan devices. Probably needs to block too, but could reuse the surface!
ASSERT(previousSwapChain->GetDevice() == GetDevice());
// The previous swapchain was on the same Vulkan device so we can use Vulkan's
// "oldSwapchain" mechanism to ensure a seamless transition. We track the old swapchain
// for release immediately so it is not leaked in case of an error. (Vulkan allows
// destroying it immediately after the call to vkCreateSwapChainKHR but tracking
// using the fenced deleter makes the code simpler).
std::swap(previousVulkanSwapChain->mSwapChain, oldVkSwapChain);
device->GetFencedDeleter()->DeleteWhenUnused(oldVkSwapChain);
previousSwapChain->DetachFromSurface();
}
if (mVkSurface == VK_NULL_HANDLE) {
DAWN_TRY_ASSIGN(mVkSurface, CreateVulkanSurface(adapter->GetBackend(), GetSurface()));
}
VulkanSurfaceInfo surfaceInfo;
DAWN_TRY_ASSIGN(surfaceInfo, GatherSurfaceInfo(*adapter, mVkSurface));
DAWN_TRY_ASSIGN(mConfig, ChooseConfig(surfaceInfo));
// TODO Choose config instead of hardcoding
VkSwapchainCreateInfoKHR createInfo;
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
createInfo.pNext = nullptr;
createInfo.flags = 0;
createInfo.surface = mVkSurface;
createInfo.minImageCount = 3; // TODO
createInfo.imageFormat = VK_FORMAT_B8G8R8A8_UNORM; // TODO
createInfo.imageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; // TODO?
createInfo.imageExtent.width = GetWidth(); // TODO
createInfo.imageExtent.height = GetHeight(); // TODO
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
createInfo.queueFamilyIndexCount = 0;
createInfo.pQueueFamilyIndices = nullptr;
createInfo.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; // TODO
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; // TODO
createInfo.presentMode = mConfig.presentMode;
createInfo.clipped = false;
createInfo.oldSwapchain = oldVkSwapChain;
DAWN_TRY(CheckVkSuccess(device->fn.CreateSwapchainKHR(device->GetVkDevice(), &createInfo,
nullptr, &*mSwapChain),
"CreateSwapChain"));
// Gather the swapchain's images. Implementations are allowed to return more images than the
// number we asked for.
uint32_t count = 0;
DAWN_TRY(CheckVkSuccess(
device->fn.GetSwapchainImagesKHR(device->GetVkDevice(), mSwapChain, &count, nullptr),
"GetSwapChainImages1"));
// TODO(cwallez@chromium.org): Figure out if we can only have more swapchain images, or also
// less than requested (and what should happen in that case).
ASSERT(count >= 3);
mSwapChainImages.resize(count);
DAWN_TRY(CheckVkSuccess(
device->fn.GetSwapchainImagesKHR(device->GetVkDevice(), mSwapChain, &count,
AsVkArray(mSwapChainImages.data())),
"GetSwapChainImages2"));
return {};
}
ResultOrError<SwapChain::Config> SwapChain::ChooseConfig(
const VulkanSurfaceInfo& surfaceInfo) const {
Config config;
// Choose the present mode. The only guaranteed one is FIFO so it has to be the fallback for
// all other present modes. IMMEDIATE has tearing which is generally undesirable so it can't
// be the fallback for MAILBOX. So the fallback order is always IMMEDIATE -> MAILBOX ->
// FIFO.
{
auto HasPresentMode = [](const std::vector<VkPresentModeKHR>& modes,
VkPresentModeKHR target) -> bool {
return std::find(modes.begin(), modes.end(), target) != modes.end();
};
VkPresentModeKHR targetMode = ToVulkanPresentMode(GetPresentMode());
const std::array<VkPresentModeKHR, 3> kPresentModeFallbacks = {
VK_PRESENT_MODE_IMMEDIATE_KHR,
VK_PRESENT_MODE_MAILBOX_KHR,
VK_PRESENT_MODE_FIFO_KHR,
};
// Go to the target mode.
size_t modeIndex = 0;
while (kPresentModeFallbacks[modeIndex] != targetMode) {
modeIndex++;
}
// Find the first available fallback.
while (!HasPresentMode(surfaceInfo.presentModes, kPresentModeFallbacks[modeIndex])) {
modeIndex++;
}
ASSERT(modeIndex < kPresentModeFallbacks.size());
config.presentMode = kPresentModeFallbacks[modeIndex];
}
return config;
}
MaybeError SwapChain::PresentImpl() {
Device* device = ToBackend(GetDevice());
// Transition the texture to the present usage.
// TODO(cwallez@chromium.org): Remove the need for this by eagerly transitioning the
// presentable texture to present at the end of submits that use them and ideally even
// folding that in the free layout transition at the end of render passes.
CommandRecordingContext* recordingContext = device->GetPendingRecordingContext();
mTexture->TransitionUsageNow(recordingContext, kPresentTextureUsage,
mTexture->GetAllSubresources());
DAWN_TRY(device->SubmitPendingCommands());
// Assuming that the present queue is the same as the graphics queue, the proper
// synchronization has already been done on the queue so we don't need to wait on any
// semaphores.
// TODO(cwallez@chromium.org): Support the present queue not being the main queue.
VkPresentInfoKHR presentInfo;
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
presentInfo.pNext = nullptr;
presentInfo.waitSemaphoreCount = 0;
presentInfo.pWaitSemaphores = nullptr;
presentInfo.swapchainCount = 1;
presentInfo.pSwapchains = &*mSwapChain;
presentInfo.pImageIndices = &mLastImageIndex;
presentInfo.pResults = nullptr;
// Free the texture before present so error handling doesn't skip that step.
mTexture->Destroy();
mTexture = nullptr;
VkResult result =
VkResult::WrapUnsafe(device->fn.QueuePresentKHR(device->GetQueue(), &presentInfo));
if (result == VK_ERROR_OUT_OF_DATE_KHR) {
// TODO reinitialize?
} else if (result == VK_ERROR_SURFACE_LOST_KHR) {
// TODO IDK what to do here, just lose the device?
} else {
DAWN_TRY(CheckVkSuccess(::VkResult(result), "QueuePresent"));
}
return {};
}
ResultOrError<TextureViewBase*> SwapChain::GetCurrentTextureViewImpl() {
Device* device = ToBackend(GetDevice());
// Transiently create a semaphore that will be signaled when the presentation engine is done
// with the swapchain image. Further operations on the image will wait for this semaphore.
VkSemaphoreCreateInfo createInfo;
createInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
createInfo.pNext = nullptr;
createInfo.flags = 0;
VkSemaphore semaphore = VK_NULL_HANDLE;
DAWN_TRY(CheckVkSuccess(
device->fn.CreateSemaphore(device->GetVkDevice(), &createInfo, nullptr, &*semaphore),
"CreateSemaphore"));
// TODO(cwallez@chromium.org) put the semaphore on the texture so it is waited on when used
// instead of directly on the recording context?
device->GetPendingRecordingContext()->waitSemaphores.push_back(semaphore);
VkResult result = VkResult::WrapUnsafe(device->fn.AcquireNextImageKHR(
device->GetVkDevice(), mSwapChain, std::numeric_limits<uint64_t>::max(), semaphore,
VkFence{}, &mLastImageIndex));
if (result == VK_SUBOPTIMAL_KHR) {
// TODO reinitialize?
} else if (result == VK_ERROR_OUT_OF_DATE_KHR) {
// TODO reinitialize?
} else if (result == VK_ERROR_SURFACE_LOST_KHR) {
// TODO IDK what to do here, just lose the device?
} else {
DAWN_TRY(CheckVkSuccess(::VkResult(result), "AcquireNextImage"));
}
VkImage currentImage = mSwapChainImages[mLastImageIndex];
TextureDescriptor textureDesc = GetSwapChainBaseTextureDescriptor(this);
mTexture = Texture::CreateForSwapChain(device, &textureDesc, currentImage);
return mTexture->CreateView(nullptr);
}
void SwapChain::DetachFromSurfaceImpl() {
if (mTexture.Get() != nullptr) {
mTexture->Destroy();
mTexture = nullptr;
}
// The swapchain images are destroyed with the swapchain.
if (mSwapChain != VK_NULL_HANDLE) {
ToBackend(GetDevice())->GetFencedDeleter()->DeleteWhenUnused(mSwapChain);
mSwapChain = VK_NULL_HANDLE;
}
if (mVkSurface != VK_NULL_HANDLE) {
ToBackend(GetDevice())->GetFencedDeleter()->DeleteWhenUnused(mVkSurface);
mVkSurface = VK_NULL_HANDLE;
}
}
}} // namespace dawn_native::vulkan

50
src/dawn_native/vulkan/SwapChainVk.h
View File

@ -19,25 +19,65 @@
#include "common/vulkan_platform.h"
#include <vector>
namespace dawn_native { namespace vulkan {
class Device;
class Texture;
struct VulkanSurfaceInfo;
class SwapChain final : public OldSwapChainBase {
class OldSwapChain : public OldSwapChainBase {
public:
static SwapChain* Create(Device* device, const SwapChainDescriptor* descriptor);
static OldSwapChain* Create(Device* device, const SwapChainDescriptor* descriptor);
protected:
SwapChain(Device* device, const SwapChainDescriptor* descriptor);
~SwapChain() override;
OldSwapChain(Device* device, const SwapChainDescriptor* descriptor);
~OldSwapChain() override;
TextureBase* GetNextTextureImpl(const TextureDescriptor* descriptor) override;
MaybeError OnBeforePresent(TextureViewBase* view) override;
MaybeError OnBeforePresent(TextureViewBase* texture) override;
private:
wgpu::TextureUsage mTextureUsage;
};
class SwapChain : public NewSwapChainBase {
public:
static ResultOrError<SwapChain*> Create(Device* device,
Surface* surface,
NewSwapChainBase* previousSwapChain,
const SwapChainDescriptor* descriptor);
~SwapChain() override;
private:
using NewSwapChainBase::NewSwapChainBase;
MaybeError Initialize(NewSwapChainBase* previousSwapChain);
struct Config {
// Information that's passed to swapchain creation.
VkPresentModeKHR presentMode;
// TODO more information used to create the swapchain.
// TODO information about the blit that needs to happen.
};
ResultOrError<Config> ChooseConfig(const VulkanSurfaceInfo& surfaceInfo) const;
// NewSwapChainBase implementation
MaybeError PresentImpl() override;
ResultOrError<TextureViewBase*> GetCurrentTextureViewImpl() override;
void DetachFromSurfaceImpl() override;
Config mConfig;
VkSurfaceKHR mVkSurface = VK_NULL_HANDLE;
VkSwapchainKHR mSwapChain = VK_NULL_HANDLE;
std::vector<VkImage> mSwapChainImages;
uint32_t mLastImageIndex = 0;
Ref<Texture> mTexture;
};
}} // namespace dawn_native::vulkan
#endif // DAWNNATIVE_VULKAN_SWAPCHAINVK_H_