LOGICAL swapChainPlatformConnect( struct SwapChain *swapChain,
xcb_connection_t *connection,
xcb_window_t *window )
#endif
{
VkResult result;
#if defined(_WIN32)
vl.surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
vl.surfaceCreateInfo.hinstance = handle;
vl.surfaceCreateInfo.hwnd = window;
result = vkCreateWin32SurfaceKHR( swapChain->instance,
&vl.surfaceCreateInfo,
NULL,
&swapChain->surface );
#elif defined(__ANDROID__)
vl.surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
vl.surfaceCreateInfo.window = window;
result = vkCreateAndroidSurfaceKHR( swapChain->instance,
&surfaceCreateInfo,
NULL,
&swapChain->surface );
#else
vl.surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
vl.surfaceCreateInfo.connection = connection;
vl.surfaceCreateInfo.window = window;
result = vkCreateXcbSurfaceKHR( swapChain->instance,
&surfaceCreateInfo,
NULL,
&swapChain->surface );
#endif
return result == VK_SUCCESS;
}
void SwapChain::InitSurface(void * WindowHandle)
{
#if K3DPLATFORM_OS_WIN
VkWin32SurfaceCreateInfoKHR SurfaceCreateInfo = {};
SurfaceCreateInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
SurfaceCreateInfo.hinstance = GetModuleHandle(nullptr);
SurfaceCreateInfo.hwnd = (HWND)WindowHandle;
K3D_VK_VERIFY(vkCreateWin32SurfaceKHR(RHIRoot::GetInstance(), &SurfaceCreateInfo, nullptr, &m_Surface));
#elif K3DPLATFORM_OS_ANDROID
VkAndroidSurfaceCreateInfoKHR SurfaceCreateInfo = {};
SurfaceCreateInfo.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
SurfaceCreateInfo.window = (ANativeWindow*)WindowHandle;
K3D_VK_VERIFY(vkCreateAndroidSurfaceKHR(RHIRoot::GetInstance(), &SurfaceCreateInfo, nullptr, &m_Surface));
#endif
}
void VulkanContext::ReinitSurface(int width, int height) {
if (surface_ != VK_NULL_HANDLE) {
ILOG("Destroying Vulkan surface (%d, %d)", width_, height_);
vkDestroySurfaceKHR(instance_, surface_, nullptr);
surface_ = VK_NULL_HANDLE;
}
ILOG("Creating Vulkan surface (%d, %d)", width, height);
switch (winsys_) {
#ifdef _WIN32
case WINDOWSYSTEM_WIN32:
{
HINSTANCE connection = (HINSTANCE)winsysData1_;
HWND window = (HWND)winsysData2_;
RECT rc;
GetClientRect(window, &rc);
width = rc.right - rc.left;
height = rc.bottom - rc.top;
VkWin32SurfaceCreateInfoKHR win32{ VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR };
win32.flags = 0;
win32.hwnd = window;
win32.hinstance = connection;
VkResult res = vkCreateWin32SurfaceKHR(instance_, &win32, nullptr, &surface_);
assert(res == VK_SUCCESS);
break;
}
#endif
#if defined(__ANDROID__)
case WINDOWSYSTEM_ANDROID:
{
ANativeWindow *wnd = (ANativeWindow *)winsysData1_;
VkAndroidSurfaceCreateInfoKHR android{ VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR };
android.flags = 0;
android.window = wnd;
VkResult res = vkCreateAndroidSurfaceKHR(instance_, &android, nullptr, &surface_);
assert(res == VK_SUCCESS);
break;
}
#endif
#if defined(VK_USE_PLATFORM_XLIB_KHR)
case WINDOWSYSTEM_XLIB:
{
VkXlibSurfaceCreateInfoKHR xlib = { VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR };
xlib.flags = 0;
xlib.dpy = (Display *)winsysData1_;
xlib.window = (Window)winsysData2_;
VkResult res = vkCreateXlibSurfaceKHR(instance_, &xlib, nullptr, &surface_);
assert(res == VK_SUCCESS);
break;
}
#endif
#if defined(VK_USE_PLATFORM_XCB_KHR)
case WINDOWSYSTEM_XCB:
{
VkXCBSurfaceCreateInfoKHR xcb = { VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR };
xcb.flags = 0;
xcb.connection = (Connection *)winsysData1_;
xcb.window = (Window)(uintptr_t)winsysData2_;
VkResult res = vkCreateXcbSurfaceKHR(instance_, &xcb, nullptr, &surface_);
assert(res == VK_SUCCESS);
break;
}
#endif
#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
case WINDOWSYSTEM_WAYLAND:
{
VkWaylandSurfaceCreateInfoKHR wayland = { VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR };
wayland.flags = 0;
wayland.display = (wl_display *)winsysData1_;
wayland.surface = (wl_surface *)winsysData2_;
VkResult res = vkCreateWaylandSurfaceKHR(instance_, &wayland, nullptr, &surface_);
assert(res == VK_SUCCESS);
break;
}
#endif
default:
_assert_msg_(G3D, false, "Vulkan support for chosen window system not implemented");
break;
}
width_ = width;
height_ = height;
}
int XdevLSwapChainVulkan::createSurface(IPXdevLWindow window) {
Display* display = static_cast<Display*>(window->getInternal(XdevLInternalName("X11_DISPLAY")));
if(nullptr == display) {
XDEVL_MODULEX_ERROR(XdevLSwapChainVulkan, "Could not get native X11 display information.\n");
return RET_FAILED;
}
Window x11window = (Window)(window->getInternal(XdevLInternalName("X11_WINDOW")));
if(None == x11window) {
XDEVL_MODULEX_ERROR(XdevLSwapChainVulkan, "Could not get native X11 window information.\n");
return RET_FAILED;
}
//
// Get the Surface extensions.
//
VkResult result;
#if defined(_WIN32)
VkWin32SurfaceCreateInfoKHR surfaceCreateInfo;
surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
surfaceCreateInfo.hinstance = (HINSTANCE)platformHandle; // provided by the platform code
surfaceCreateInfo.hwnd = (HWND)platformWindow; // provided by the platform code
result = vkCreateWin32SurfaceKHR(instance, &surfaceCreateInfo, nullptr, &m_surface);
#elif defined(__ANDROID__)
VkAndroidSurfaceCreateInfoKHR surfaceCreateInfo;
surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
surfaceCreateInfo.window = window; // provided by the platform code
result = vkCreateAndroidSurfaceKHR(instance, &surfaceCreateInfo, nullptr, &m_surface);
#else
VkXcbSurfaceCreateInfoKHR surfaceCreateInfo = {
VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR,
nullptr,
0,
XGetXCBConnection(display),
(xcb_window_t)x11window
};
result = vkCreateXcbSurfaceKHR(m_instance, &surfaceCreateInfo, nullptr, &m_surface);
#endif
if(result != VK_SUCCESS) {
std::cerr << "Failed to create Vulkan surface: " << vkVkResultToString(result) << std::endl;
return 1;
}
uint32_t queueCount;
vkGetPhysicalDeviceQueueFamilyProperties(m_physicalDevice, &queueCount, nullptr);
std::vector<VkQueueFamilyProperties> queueProps(queueCount);
vkGetPhysicalDeviceQueueFamilyProperties(m_physicalDevice, &queueCount, queueProps.data());
// Will be used to present the swap chain images to the windowing system
std::vector<VkBool32> supportsPresent(queueCount);
for(uint32_t i = 0; i < queueCount; i++) {
fpGetPhysicalDeviceSurfaceSupportKHR(m_physicalDevice, i, m_surface, &supportsPresent[i]);
}
// Search for a graphics and a present queue in the array of queue
// families, try to find one that supports both
uint32_t graphicsQueueNodeIndex = UINT32_MAX;
uint32_t presentQueueNodeIndex = UINT32_MAX;
for(uint32_t i = 0; i < queueCount; i++) {
if((queueProps[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) != 0) {
if(graphicsQueueNodeIndex == UINT32_MAX) {
graphicsQueueNodeIndex = i;
}
if(supportsPresent[i] == VK_TRUE) {
graphicsQueueNodeIndex = i;
presentQueueNodeIndex = i;
break;
}
}
}
if(presentQueueNodeIndex == UINT32_MAX) {
// If there's no queue that supports both present and graphics
// try to find a separate present queue
for(uint32_t i = 0; i < queueCount; ++i) {
if(supportsPresent[i] == VK_TRUE) {
presentQueueNodeIndex = i;
break;
}
}
}
// Exit if either a graphics or a presenting queue hasn't been found
if(graphicsQueueNodeIndex == UINT32_MAX || presentQueueNodeIndex == UINT32_MAX) {
return 1;
}
// todo : Add support for separate graphics and presenting queue
if(graphicsQueueNodeIndex != presentQueueNodeIndex) {
return 1;
}
m_queueNodeIndex = graphicsQueueNodeIndex;
// Get list of supported surface formats
uint32_t formatCount;
result = vkGetPhysicalDeviceSurfaceFormatsKHR(m_physicalDevice, m_surface, &formatCount, nullptr);
if(VK_SUCCESS != result) {
std::cerr << "vkGetPhysicalDeviceSurfaceFormatsKHR failed: " << vkVkResultToString(result) << std::endl;
return 1;
}
assert(formatCount > 0);
std::vector<VkSurfaceFormatKHR> surfaceFormats(formatCount);
result = vkGetPhysicalDeviceSurfaceFormatsKHR(m_physicalDevice, m_surface, &formatCount, surfaceFormats.data());
assert(!result);
// If the surface format list only includes one entry with VK_FORMAT_UNDEFINED,
// there is no preferered format, so we assume VK_FORMAT_B8G8R8A8_UNORM
if((formatCount == 1) && (surfaceFormats[0].format == VK_FORMAT_UNDEFINED)) {
m_colorFormat = VK_FORMAT_B8G8R8A8_UNORM;
} else {
// Always select the first available color format
// If you need a specific format (e.g. SRGB) you'd need to
// iterate over the list of available surface format and
// check for it's presence
m_colorFormat = surfaceFormats[0].format;
}
m_colorSpace = surfaceFormats[0].colorSpace;
return 0;
}
bool initialize(android_app* app) {
// Load Android vulkan and retrieve vulkan API function pointers
if (!InitVulkan()) {
LOGE("Vulkan is unavailable, install vulkan and re-start");
return false;
}
VkApplicationInfo appInfo = {
.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
.pNext = nullptr,
.apiVersion = VK_MAKE_VERSION(1, 0, 0),
.applicationVersion = VK_MAKE_VERSION(1, 0, 0),
.engineVersion = VK_MAKE_VERSION(1, 0, 0),
.pApplicationName = "tutorial01_load_vulkan",
.pEngineName = "tutorial",
};
// prepare necessary extensions: Vulkan on Android need these to function
std::vector<const char *> instanceExt, deviceExt;
instanceExt.push_back("VK_KHR_surface");
instanceExt.push_back("VK_KHR_android_surface");
deviceExt.push_back("VK_KHR_swapchain");
// Create the Vulkan instance
VkInstanceCreateInfo instanceCreateInfo {
.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
.pNext = nullptr,
.pApplicationInfo = &appInfo,
.enabledExtensionCount = static_cast<uint32_t>(instanceExt.size()),
.ppEnabledExtensionNames = instanceExt.data(),
.enabledLayerCount = 0,
.ppEnabledLayerNames = nullptr,
};
CALL_VK(vkCreateInstance(&instanceCreateInfo, nullptr, &tutorialInstance));
// if we create a surface, we need the surface extension
VkAndroidSurfaceCreateInfoKHR createInfo {
.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR,
.pNext = nullptr,
.flags = 0,
.window = app->window };
CALL_VK(vkCreateAndroidSurfaceKHR(tutorialInstance, &createInfo, nullptr,
&tutorialSurface));
// Find one GPU to use:
// On Android, every GPU device is equal -- supporting graphics/compute/present
// for this sample, we use the very first GPU device found on the system
uint32_t gpuCount = 0;
CALL_VK(vkEnumeratePhysicalDevices(tutorialInstance, &gpuCount, nullptr));
VkPhysicalDevice tmpGpus[gpuCount];
CALL_VK(vkEnumeratePhysicalDevices(tutorialInstance, &gpuCount, tmpGpus));
tutorialGpu = tmpGpus[0]; // Pick up the first GPU Device
// check for vulkan info on this GPU device
VkPhysicalDeviceProperties gpuProperties;
vkGetPhysicalDeviceProperties(tutorialGpu, &gpuProperties);
LOGI("Vulkan Physical Device Name: %s", gpuProperties.deviceName);
LOGI("Vulkan Physical Device Info: apiVersion: %x \n\t driverVersion: %x",
gpuProperties.apiVersion, gpuProperties.driverVersion);
LOGI("API Version Supported: %d.%d.%d",
VK_VERSION_MAJOR(gpuProperties.apiVersion),
VK_VERSION_MINOR(gpuProperties.apiVersion),
VK_VERSION_PATCH(gpuProperties.apiVersion));
VkSurfaceCapabilitiesKHR surfaceCapabilities;
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(tutorialGpu,
tutorialSurface,
&surfaceCapabilities);
LOGI("Vulkan Surface Capabilities:\n");
LOGI("\timage count: %u - %u\n", surfaceCapabilities.minImageCount,
surfaceCapabilities.maxImageCount);
LOGI("\tarray layers: %u\n", surfaceCapabilities.maxImageArrayLayers);
LOGI("\timage size (now): %dx%d\n",
surfaceCapabilities.currentExtent.width,
surfaceCapabilities.currentExtent.height);
LOGI("\timage size (extent): %dx%d - %dx%d\n",
surfaceCapabilities.minImageExtent.width,
surfaceCapabilities.minImageExtent.height,
surfaceCapabilities.maxImageExtent.width,
surfaceCapabilities.maxImageExtent.height);
LOGI("\tusage: %x\n", surfaceCapabilities.supportedUsageFlags);
LOGI("\tcurrent transform: %u\n", surfaceCapabilities.currentTransform);
LOGI("\tallowed transforms: %x\n", surfaceCapabilities.supportedTransforms);
LOGI("\tcomposite alpha flags: %u\n", surfaceCapabilities.currentTransform);
// Create a logical device from GPU we picked
float priorities[] = { 1.0f, };
VkDeviceQueueCreateInfo queueCreateInfo {
.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.queueCount = 1,
.queueFamilyIndex = 0,
.pQueuePriorities = priorities,
};
VkDeviceCreateInfo deviceCreateInfo {
.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
.pNext = nullptr,
.queueCreateInfoCount = 1,
.pQueueCreateInfos = &queueCreateInfo,
.enabledLayerCount = 0,
.ppEnabledLayerNames = nullptr,
.enabledExtensionCount = static_cast<uint32_t>(deviceExt.size()),
.ppEnabledExtensionNames = deviceExt.data(),
.pEnabledFeatures = nullptr,
};
CALL_VK(vkCreateDevice(tutorialGpu, &deviceCreateInfo, nullptr,
&tutorialDevice));
initialized_ = true;
return 0;
}
void terminate() {
vkDestroySurfaceKHR(tutorialInstance, tutorialSurface, nullptr);
vkDestroyDevice(tutorialDevice, nullptr);
vkDestroyInstance(tutorialInstance, nullptr);
initialized_ = false;
}
// Process the next main command.
void handle_cmd(android_app* app, int32_t cmd) {
switch (cmd) {
case APP_CMD_INIT_WINDOW:
// The window is being shown, get it ready.
initialize(app);
break;
case APP_CMD_TERM_WINDOW:
// The window is being hidden or closed, clean it up.
terminate();
break;
default:
LOGI("event not handled: %d", cmd);
}
}
FVulkanSwapChain::FVulkanSwapChain(VkInstance Instance, FVulkanDevice& InDevice, void* WindowHandle, EPixelFormat& InOutPixelFormat, uint32 Width, uint32 Height,
uint32* InOutDesiredNumBackBuffers, TArray<VkImage>& OutImages)
: SwapChain(VK_NULL_HANDLE)
, Device(InDevice)
, Surface(VK_NULL_HANDLE)
, CurrentImageIndex(-1)
, SemaphoreIndex(0)
{
#if PLATFORM_WINDOWS
VkWin32SurfaceCreateInfoKHR SurfaceCreateInfo;
FMemory::Memzero(SurfaceCreateInfo);
SurfaceCreateInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
SurfaceCreateInfo.hinstance = GetModuleHandle(nullptr);
SurfaceCreateInfo.hwnd = (HWND)WindowHandle;
VERIFYVULKANRESULT(vkCreateWin32SurfaceKHR(Instance, &SurfaceCreateInfo, nullptr, &Surface));
#elif PLATFORM_ANDROID
VkAndroidSurfaceCreateInfoKHR SurfaceCreateInfo;
FMemory::Memzero(SurfaceCreateInfo);
SurfaceCreateInfo.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
SurfaceCreateInfo.window = (ANativeWindow*)WindowHandle;
VERIFYVULKANRESULT(vkCreateAndroidSurfaceKHR(Instance, &SurfaceCreateInfo, nullptr, &Surface));
#else
static_assert(false, "Unsupported Vulkan platform!");
#endif
// Find Pixel format for presentable images
VkSurfaceFormatKHR CurrFormat;
FMemory::Memzero(CurrFormat);
{
uint32 NumFormats;
VERIFYVULKANRESULT_EXPANDED(VulkanRHI::vkGetPhysicalDeviceSurfaceFormatsKHR(Device.GetPhysicalHandle(), Surface, &NumFormats, nullptr));
check(NumFormats > 0);
TArray<VkSurfaceFormatKHR> Formats;
Formats.AddZeroed(NumFormats);
VERIFYVULKANRESULT_EXPANDED(VulkanRHI::vkGetPhysicalDeviceSurfaceFormatsKHR(Device.GetPhysicalHandle(), Surface, &NumFormats, Formats.GetData()));
if (Formats.Num() == 1 && Formats[0].format == VK_FORMAT_UNDEFINED && InOutPixelFormat == PF_Unknown)
{
InOutPixelFormat = PF_B8G8R8A8;
}
else if (InOutPixelFormat == PF_Unknown)
{
// Reverse lookup
check(Formats[0].format != VK_FORMAT_UNDEFINED);
for (int32 Index = 0; Index < PF_MAX; ++Index)
{
if (Formats[0].format == GPixelFormats[Index].PlatformFormat)
{
InOutPixelFormat = (EPixelFormat)Index;
CurrFormat = Formats[0];
break;
}
}
}
else
{
VkFormat PlatformFormat = UEToVkFormat(InOutPixelFormat, false);
bool bSupported = false;
for (int32 Index = 0; Index < Formats.Num(); ++Index)
{
if (Formats[Index].format == PlatformFormat)
{
bSupported = true;
CurrFormat = Formats[Index];
break;
}
}
check(bSupported);
}
}
VkFormat PlatformFormat = UEToVkFormat(InOutPixelFormat, false);
//#todo-rco: Check multiple Gfx Queues?
VkBool32 bSupportsPresent = VK_FALSE;
VERIFYVULKANRESULT(VulkanRHI::vkGetPhysicalDeviceSurfaceSupportKHR(Device.GetPhysicalHandle(), Device.GetQueue()->GetFamilyIndex(), Surface, &bSupportsPresent));
//#todo-rco: Find separate present queue if the gfx one doesn't support presents
check(bSupportsPresent);
// Fetch present mode
VkPresentModeKHR PresentMode = VK_PRESENT_MODE_FIFO_KHR;
#if !PLATFORM_ANDROID
{
uint32 NumFoundPresentModes = 0;
VERIFYVULKANRESULT(VulkanRHI::vkGetPhysicalDeviceSurfacePresentModesKHR(Device.GetPhysicalHandle(), Surface, &NumFoundPresentModes, nullptr));
check(NumFoundPresentModes > 0);
TArray<VkPresentModeKHR> FoundPresentModes;
FoundPresentModes.AddZeroed(NumFoundPresentModes);
VERIFYVULKANRESULT(VulkanRHI::vkGetPhysicalDeviceSurfacePresentModesKHR(Device.GetPhysicalHandle(), Surface, &NumFoundPresentModes, FoundPresentModes.GetData()));
bool bFoundDesiredMode = false;
for (size_t i = 0; i < NumFoundPresentModes; i++)
{
if (FoundPresentModes[i] == PresentMode)
{
bFoundDesiredMode = true;
break;
}
}
if (!bFoundDesiredMode)
{
UE_LOG(LogVulkanRHI, Warning, TEXT("Couldn't find Present Mode %d!"), (int32)PresentMode);
PresentMode = FoundPresentModes[0];
}
}
#endif
// Check the surface properties and formats
VkSurfaceCapabilitiesKHR SurfProperties;
VERIFYVULKANRESULT_EXPANDED(VulkanRHI::vkGetPhysicalDeviceSurfaceCapabilitiesKHR(Device.GetPhysicalHandle(),
Surface,
&SurfProperties));
VkSurfaceTransformFlagBitsKHR PreTransform;
if (SurfProperties.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR)
{
PreTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
}
else
{
PreTransform = SurfProperties.currentTransform;
}
// 0 means no limit, so use the requested number
uint32 DesiredNumBuffers = SurfProperties.maxImageCount > 0 ? FMath::Clamp(*InOutDesiredNumBackBuffers, SurfProperties.minImageCount, SurfProperties.maxImageCount) : *InOutDesiredNumBackBuffers;
VkSwapchainCreateInfoKHR SwapChainInfo;
FMemory::Memzero(SwapChainInfo);
SwapChainInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
SwapChainInfo.surface = Surface;
SwapChainInfo.minImageCount = DesiredNumBuffers;
SwapChainInfo.imageFormat = CurrFormat.format;
SwapChainInfo.imageColorSpace = CurrFormat.colorSpace;
SwapChainInfo.imageExtent.width = PLATFORM_ANDROID ? Width : (SurfProperties.currentExtent.width == -1 ? Width : SurfProperties.currentExtent.width);
SwapChainInfo.imageExtent.height = PLATFORM_ANDROID ? Height : (SurfProperties.currentExtent.height == -1 ? Height : SurfProperties.currentExtent.height);
SwapChainInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
SwapChainInfo.preTransform = PreTransform;
SwapChainInfo.imageArrayLayers = 1;
SwapChainInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
SwapChainInfo.presentMode = PresentMode;
SwapChainInfo.oldSwapchain = VK_NULL_HANDLE;
SwapChainInfo.clipped = VK_TRUE;
SwapChainInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
*InOutDesiredNumBackBuffers = DesiredNumBuffers;
VERIFYVULKANRESULT_EXPANDED(VulkanRHI::vkCreateSwapchainKHR(Device.GetInstanceHandle(), &SwapChainInfo, nullptr, &SwapChain));
uint32 NumSwapChainImages;
VERIFYVULKANRESULT_EXPANDED(VulkanRHI::vkGetSwapchainImagesKHR(Device.GetInstanceHandle(), SwapChain, &NumSwapChainImages, nullptr));
OutImages.AddUninitialized(NumSwapChainImages);
VERIFYVULKANRESULT_EXPANDED(VulkanRHI::vkGetSwapchainImagesKHR(Device.GetInstanceHandle(), SwapChain, &NumSwapChainImages, OutImages.GetData()));
ImageAcquiredSemaphore.AddUninitialized(DesiredNumBuffers);
for (uint32 BufferIndex = 0; BufferIndex < DesiredNumBuffers; ++BufferIndex)
{
ImageAcquiredSemaphore[BufferIndex] = new FVulkanSemaphore(Device);
}
}
//[-------------------------------------------------------]
//[ Public methods ]
//[-------------------------------------------------------]
SwapChain::SwapChain(VulkanRenderer &vulkanRenderer, handle nativeWindowHandle) :
ISwapChain(vulkanRenderer),
mNativeWindowHandle(nativeWindowHandle),
mVkSurfaceKHR(VK_NULL_HANDLE),
mVkSwapchainKHR(VK_NULL_HANDLE),
mSwapchainImageCount(0)
{
// Get the Vulkan instance and the Vulkan physical device
const VkInstance vkInstance = vulkanRenderer.getVulkanRuntimeLinking().getVkInstance();
const IContext& context = vulkanRenderer.getContext();
const VkPhysicalDevice vkPhysicalDevice = context.getVkPhysicalDevice();
const VkDevice vkDevice = context.getVkDevice();
// Create Vulkan surface instance depending on OS
#ifdef _WIN32
VkWin32SurfaceCreateInfoKHR vkWin32SurfaceCreateInfoKHR = {};
vkWin32SurfaceCreateInfoKHR.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
vkWin32SurfaceCreateInfoKHR.hinstance = reinterpret_cast<HINSTANCE>(::GetWindowLong(reinterpret_cast<HWND>(nativeWindowHandle), GWL_HINSTANCE));
vkWin32SurfaceCreateInfoKHR.hwnd = reinterpret_cast<HWND>(nativeWindowHandle);
VkResult vkResult = vkCreateWin32SurfaceKHR(vkInstance, &vkWin32SurfaceCreateInfoKHR, nullptr, &mVkSurfaceKHR);
#else
#ifdef __ANDROID__
// TODO(co) Not tested - see https://github.com/SaschaWillems/Vulkan
VkAndroidSurfaceCreateInfoKHR vkAndroidSurfaceCreateInfoKHR = {};
vkAndroidSurfaceCreateInfoKHR.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
vkAndroidSurfaceCreateInfoKHR.window = window;
VkResult vkResult = vkCreateAndroidSurfaceKHR(vkInstance, &vkAndroidSurfaceCreateInfoKHR, nullptr, &mVkSurfaceKHR);
#else
// TODO(co) Not tested - see https://github.com/SaschaWillems/Vulkan
VkXcbSurfaceCreateInfoKHR vkXcbSurfaceCreateInfoKHR = {};
vkXcbSurfaceCreateInfoKHR.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
vkXcbSurfaceCreateInfoKHR.connection = connection;
vkXcbSurfaceCreateInfoKHR.window = window;
VkResult vkResult = vkCreateXcbSurfaceKHR(vkInstance, &vkXcbSurfaceCreateInfoKHR, nullptr, &mVkSurfaceKHR);
#endif
#endif
// Get list of supported surface formats
uint32_t surfaceFormatCount = 0;
vkResult = vkGetPhysicalDeviceSurfaceFormatsKHR(vkPhysicalDevice, mVkSurfaceKHR, &surfaceFormatCount, nullptr);
// assert(!vkResult);
// assert(surfaceFormatCount > 0);
std::vector<VkSurfaceFormatKHR> vkSurfaceFormatKHRs(surfaceFormatCount);
vkResult = vkGetPhysicalDeviceSurfaceFormatsKHR(vkPhysicalDevice, mVkSurfaceKHR, &surfaceFormatCount, vkSurfaceFormatKHRs.data());
// assert(!vkResult);
// If the surface format list only includes one entry with VK_FORMAT_UNDEFINED,
// there is no preferred format, so we assume VK_FORMAT_B8G8R8A8_UNORM
VkFormat colorVkFormat;
if ((surfaceFormatCount == 1) && (vkSurfaceFormatKHRs[0].format == VK_FORMAT_UNDEFINED))
{
colorVkFormat = VK_FORMAT_B8G8R8A8_UNORM;
}
else
{
// Always select the first available color format
// If you need a specific format (e.g. SRGB) you'd need to
// iterate over the list of available surface format and
// check for it's presence
colorVkFormat = vkSurfaceFormatKHRs[0].format;
}
VkColorSpaceKHR vkColorSpaceKHR = vkSurfaceFormatKHRs[0].colorSpace;
// Get the width and height of the given native window and ensure they are never ever zero
// -> See "getSafeWidthAndHeight()"-method comments for details
uint32_t width = 1;
uint32_t height = 1;
#ifdef _WIN32
{
// Get the client rectangle of the given native window
RECT rect;
::GetClientRect(reinterpret_cast<HWND>(nativeWindowHandle), &rect);
// Get the width and height...
width = static_cast<uint32_t>(rect.right - rect.left);
height = static_cast<uint32_t>(rect.bottom - rect.top);
// ... and ensure that none of them is ever zero
if (width < 1)
{
width = 1;
}
if (height < 1)
{
height = 1;
}
}
#endif
// TODO(co) Move the rest into a method
VkSwapchainKHR oldVkSwapchainKHR = mVkSwapchainKHR;
// Get physical device surface properties and formats
VkSurfaceCapabilitiesKHR vkSurfaceCapabilitiesKHR;
vkResult = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vkPhysicalDevice, mVkSurfaceKHR, &vkSurfaceCapabilitiesKHR);
// assert(!vkResult);
// Get available present modes
uint32_t presentModeCount = 0;
vkResult = vkGetPhysicalDeviceSurfacePresentModesKHR(vkPhysicalDevice, mVkSurfaceKHR, &presentModeCount, nullptr);
// assert(!vkResult);
// assert(presentModeCount > 0);
std::vector<VkPresentModeKHR> vkPresentModeKHRs(presentModeCount);
vkResult = vkGetPhysicalDeviceSurfacePresentModesKHR(vkPhysicalDevice, mVkSurfaceKHR, &presentModeCount, vkPresentModeKHRs.data());
// assert(!vkResult);
// Width and height are either both -1, or both not -1.
VkExtent2D swapchainExtent = {};
if (vkSurfaceCapabilitiesKHR.currentExtent.width == -1)
{
// If the surface size is undefined, the size is set to
// the size of the images requested.
swapchainExtent.width = width;
swapchainExtent.height = height;
}
else
{
// If the surface size is defined, the swap chain size must match
swapchainExtent = vkSurfaceCapabilitiesKHR.currentExtent;
width = vkSurfaceCapabilitiesKHR.currentExtent.width;
height = vkSurfaceCapabilitiesKHR.currentExtent.height;
}
// Prefer mailbox mode if present, it's the lowest latency non-tearing present mode
VkPresentModeKHR swapchainPresentMode = VK_PRESENT_MODE_FIFO_KHR;
for (size_t i = 0; i < presentModeCount; ++i)
{
if (vkPresentModeKHRs[i] == VK_PRESENT_MODE_MAILBOX_KHR)
{
swapchainPresentMode = VK_PRESENT_MODE_MAILBOX_KHR;
break;
}
if ((swapchainPresentMode != VK_PRESENT_MODE_MAILBOX_KHR) && (vkPresentModeKHRs[i] == VK_PRESENT_MODE_IMMEDIATE_KHR))
{
swapchainPresentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
}
}
// Determine the number of images
uint32_t desiredNumberOfSwapchainImages = vkSurfaceCapabilitiesKHR.minImageCount + 1;
if ((vkSurfaceCapabilitiesKHR.maxImageCount > 0) && (desiredNumberOfSwapchainImages > vkSurfaceCapabilitiesKHR.maxImageCount))
{
desiredNumberOfSwapchainImages = vkSurfaceCapabilitiesKHR.maxImageCount;
}
VkSurfaceTransformFlagsKHR vkSurfaceTransformFlagsKHR;
if (vkSurfaceCapabilitiesKHR.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR)
{
vkSurfaceTransformFlagsKHR = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
}
else
{
vkSurfaceTransformFlagsKHR = vkSurfaceCapabilitiesKHR.currentTransform;
}
VkSwapchainCreateInfoKHR vkSwapchainCreateInfoKHR = {};
vkSwapchainCreateInfoKHR.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
vkSwapchainCreateInfoKHR.surface = mVkSurfaceKHR;
vkSwapchainCreateInfoKHR.minImageCount = desiredNumberOfSwapchainImages;
vkSwapchainCreateInfoKHR.imageFormat = colorVkFormat;
vkSwapchainCreateInfoKHR.imageColorSpace = vkColorSpaceKHR;
vkSwapchainCreateInfoKHR.imageExtent = { swapchainExtent.width, swapchainExtent.height };
vkSwapchainCreateInfoKHR.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
vkSwapchainCreateInfoKHR.preTransform = static_cast<VkSurfaceTransformFlagBitsKHR>(vkSurfaceTransformFlagsKHR);
vkSwapchainCreateInfoKHR.imageArrayLayers = 1;
vkSwapchainCreateInfoKHR.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
vkSwapchainCreateInfoKHR.presentMode = swapchainPresentMode;
vkSwapchainCreateInfoKHR.oldSwapchain = oldVkSwapchainKHR;
vkSwapchainCreateInfoKHR.clipped = true;
vkSwapchainCreateInfoKHR.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
vkResult = vkCreateSwapchainKHR(vkDevice, &vkSwapchainCreateInfoKHR, nullptr, &mVkSwapchainKHR);
// assert(!vkResult);
// If an existing swap chain is re-created, destroy the old swap chain
// This also cleans up all the presentable images
if (VK_NULL_HANDLE != oldVkSwapchainKHR)
{
for (uint32_t i = 0; i < mSwapchainImageCount; ++i)
{
vkDestroyImageView(vkDevice, mSwapChainBuffer[i].view, nullptr);
}
vkDestroySwapchainKHR(vkDevice, oldVkSwapchainKHR, nullptr);
}
vkResult = vkGetSwapchainImagesKHR(vkDevice, mVkSwapchainKHR, &mSwapchainImageCount, nullptr);
// assert(!vkResult);
// Get the swap chain images
mVkImages.resize(mSwapchainImageCount);
vkResult = vkGetSwapchainImagesKHR(vkDevice, mVkSwapchainKHR, &mSwapchainImageCount, mVkImages.data());
// assert(!vkResult);
// Get the swap chain buffers containing the image and image view
mSwapChainBuffer.resize(mSwapchainImageCount);
for (uint32_t i = 0; i < mSwapchainImageCount; ++i)
{
VkImageViewCreateInfo colorAttachmentView = {};
colorAttachmentView.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
colorAttachmentView.format = colorVkFormat;
colorAttachmentView.components = {
VK_COMPONENT_SWIZZLE_R,
VK_COMPONENT_SWIZZLE_G,
VK_COMPONENT_SWIZZLE_B,
VK_COMPONENT_SWIZZLE_A
};
colorAttachmentView.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
colorAttachmentView.subresourceRange.levelCount = 1;
colorAttachmentView.subresourceRange.layerCount = 1;
colorAttachmentView.viewType = VK_IMAGE_VIEW_TYPE_2D;
mSwapChainBuffer[i].image = mVkImages[i];
// Transform images from initial (undefined) to present layout
Helper::setImageLayout(context.getSetupVkCommandBuffer(), mSwapChainBuffer[i].image, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_ASPECT_COLOR_BIT);
colorAttachmentView.image = mSwapChainBuffer[i].image;
vkResult = vkCreateImageView(vkDevice, &colorAttachmentView, nullptr, &mSwapChainBuffer[i].view);
// assert(!vkResult);
}
}
VkSurfaceKHR SwapChain::CreateVulkanSurface(VkInstance instance, void* hwnd)
{
#if defined(VK_USE_PLATFORM_WIN32_KHR)
VkWin32SurfaceCreateInfoKHR surface_create_info = {
VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR, // VkStructureType sType
nullptr, // const void* pNext
0, // VkWin32SurfaceCreateFlagsKHR flags
nullptr, // HINSTANCE hinstance
reinterpret_cast<HWND>(hwnd) // HWND hwnd
};
VkSurfaceKHR surface;
VkResult res = vkCreateWin32SurfaceKHR(instance, &surface_create_info, nullptr, &surface);
if (res != VK_SUCCESS)
{
LOG_VULKAN_ERROR(res, "vkCreateWin32SurfaceKHR failed: ");
return VK_NULL_HANDLE;
}
return surface;
#elif defined(VK_USE_PLATFORM_XLIB_KHR)
// Assuming the display handles are compatible, or shared. This matches what we do in the
// GL backend, but it's not ideal.
Display* display = XOpenDisplay(nullptr);
VkXlibSurfaceCreateInfoKHR surface_create_info = {
VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR, // VkStructureType sType
nullptr, // const void* pNext
0, // VkXlibSurfaceCreateFlagsKHR flags
display, // Display* dpy
reinterpret_cast<Window>(hwnd) // Window window
};
VkSurfaceKHR surface;
VkResult res = vkCreateXlibSurfaceKHR(instance, &surface_create_info, nullptr, &surface);
if (res != VK_SUCCESS)
{
LOG_VULKAN_ERROR(res, "vkCreateXlibSurfaceKHR failed: ");
return VK_NULL_HANDLE;
}
return surface;
#elif defined(VK_USE_PLATFORM_XCB_KHR)
// If we ever switch to using xcb, we should pass the display handle as well.
Display* display = XOpenDisplay(nullptr);
xcb_connection_t* connection = XGetXCBConnection(display);
VkXcbSurfaceCreateInfoKHR surface_create_info = {
VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR, // VkStructureType sType
nullptr, // const void* pNext
0, // VkXcbSurfaceCreateFlagsKHR flags
connection, // xcb_connection_t* connection
static_cast<xcb_window_t>(reinterpret_cast<uintptr_t>(hwnd)) // xcb_window_t window
};
VkSurfaceKHR surface;
VkResult res = vkCreateXcbSurfaceKHR(instance, &surface_create_info, nullptr, &surface);
if (res != VK_SUCCESS)
{
LOG_VULKAN_ERROR(res, "vkCreateXcbSurfaceKHR failed: ");
return VK_NULL_HANDLE;
}
return surface;
#elif defined(VK_USE_PLATFORM_ANDROID_KHR)
VkAndroidSurfaceCreateInfoKHR surface_create_info = {
VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR, // VkStructureType sType
nullptr, // const void* pNext
0, // VkAndroidSurfaceCreateFlagsKHR flags
reinterpret_cast<ANativeWindow*>(hwnd) // ANativeWindow* window
};
VkSurfaceKHR surface;
VkResult res = vkCreateAndroidSurfaceKHR(instance, &surface_create_info, nullptr, &surface);
if (res != VK_SUCCESS)
{
LOG_VULKAN_ERROR(res, "vkCreateAndroidSurfaceKHR failed: ");
return VK_NULL_HANDLE;
}
return surface;
#else
return VK_NULL_HANDLE;
#endif
}
