void create_swap_chain(VkPresentModeKHR preferred_mode, unsigned int width, unsigned int height)
{
SwapChainSupportDetails swapChainSupport = query_swap_chain_support(physical_device);
VkSurfaceFormatKHR surfaceFormat = chose_surface_format(swapChainSupport.formats);
VkPresentModeKHR presentMode = chose_prentation_mode(swapChainSupport.presentModes, preferred_mode);
VkExtent2D extent = chose_surface_extent(swapChainSupport.capabilities, width, height);
//may need that information later so it is saved in those variables
swap_chain_image_format = surfaceFormat.format;
swap_chain_extent = extent;
uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount)
{
imageCount = swapChainSupport.capabilities.maxImageCount;
}
VkSwapchainCreateInfoKHR createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
createInfo.surface = surface;
createInfo.minImageCount = imageCount;
createInfo.imageFormat = surfaceFormat.format;
createInfo.imageColorSpace = surfaceFormat.colorSpace;
createInfo.imageExtent = extent;
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
uint32_t queueFamilyIndices[] = {(uint32_t) graphics_queue_family_index, (uint32_t) present_queue_family_index};
if (graphics_queue_family_index != present_queue_family_index)
{
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
createInfo.queueFamilyIndexCount = 2;
createInfo.pQueueFamilyIndices = queueFamilyIndices;
}
else
{
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
createInfo.queueFamilyIndexCount = 0; // Optional
createInfo.pQueueFamilyIndices = nullptr; // Optional
}
createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
createInfo.presentMode = presentMode;
createInfo.clipped = VK_TRUE;
createInfo.oldSwapchain = VK_NULL_HANDLE;
if (vkCreateSwapchainKHR(device, &createInfo, nullptr, swap_chain.replace()) != VK_SUCCESS)
{
cout<<"unable to create the swap chain"<<endl;
}
vkGetSwapchainImagesKHR(device, swap_chain, &imageCount, nullptr);
swapChainImages.resize(imageCount);
vkGetSwapchainImagesKHR(device, swap_chain, &imageCount, swapChainImages.data());
}
void VkApp::createSwapChain(){
SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice);
VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);
VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities);
uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
if( swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount ){
imageCount = swapChainSupport.capabilities.maxImageCount;
}
VkSwapchainCreateInfoKHR createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
createInfo.surface = surface;
createInfo.minImageCount = imageCount;
createInfo.imageFormat = surfaceFormat.format;
createInfo.imageColorSpace = surfaceFormat.colorSpace;
createInfo.imageExtent = extent;
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
QueueFamilyIndices indices = findQueueFamilies(physicalDevice);
uint32_t queueFamilyIndices[] = {(uint32_t) indices.graphicsFamily, (uint32_t) indices.presentFamily};
if( indices.graphicsFamily != indices.presentFamily ){
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
createInfo.queueFamilyIndexCount = 2;
createInfo.pQueueFamilyIndices = queueFamilyIndices;
}
else{ createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; }
createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
createInfo.presentMode = presentMode;
createInfo.clipped = VK_TRUE;
VkSwapchainKHR oldSwapChain = swapChain;
createInfo.oldSwapchain = oldSwapChain;
VkSwapchainKHR newSwapChain;
if( vkCreateSwapchainKHR(device, &createInfo, nullptr, &newSwapChain) != VK_SUCCESS ){
throw std::runtime_error("failed to create swap chain!");
}
*&swapChain = newSwapChain;
vkGetSwapchainImagesKHR(device, swapChain, &imageCount, nullptr);
swapChainImages.resize(imageCount);
vkGetSwapchainImagesKHR(device, swapChain, &imageCount, swapChainImages.data());
swapChainImageFormat = surfaceFormat.format;
swapChainExtent = extent;
}
bool SwapChain::SetupSwapChainImages()
{
_assert_(m_swap_chain_images.empty());
uint32_t image_count;
VkResult res =
vkGetSwapchainImagesKHR(g_vulkan_context->GetDevice(), m_swap_chain, &image_count, nullptr);
if (res != VK_SUCCESS)
{
LOG_VULKAN_ERROR(res, "vkGetSwapchainImagesKHR failed: ");
return false;
}
std::vector<VkImage> images(image_count);
res = vkGetSwapchainImagesKHR(g_vulkan_context->GetDevice(), m_swap_chain, &image_count,
images.data());
_assert_(res == VK_SUCCESS);
m_swap_chain_images.reserve(image_count);
for (uint32_t i = 0; i < image_count; i++)
{
SwapChainImage image;
image.image = images[i];
// Create texture object, which creates a view of the backbuffer
image.texture = Texture2D::CreateFromExistingImage(
m_width, m_height, 1, 1, m_surface_format.format, VK_SAMPLE_COUNT_1_BIT,
VK_IMAGE_VIEW_TYPE_2D, image.image);
VkImageView view = image.texture->GetView();
VkFramebufferCreateInfo framebuffer_info = {VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
nullptr,
0,
m_render_pass,
1,
&view,
m_width,
m_height,
1};
res = vkCreateFramebuffer(g_vulkan_context->GetDevice(), &framebuffer_info, nullptr,
&image.framebuffer);
if (res != VK_SUCCESS)
{
LOG_VULKAN_ERROR(res, "vkCreateFramebuffer failed: ");
return false;
}
m_swap_chain_images.emplace_back(std::move(image));
}
return true;
}
void SurfaceWindow::initFrameBuffers() {
uint32_t nImg;
vkGetSwapchainImagesKHR(mDevice, mSwapchain, &nImg, nullptr);
mImages.resize(nImg);
vkGetSwapchainImagesKHR(mDevice, mSwapchain, &nImg, &mImages[0]);
mFrameBuffers.clear();
for(auto i(0u); i < nImg; ++i) {
std::vector<ImageView> allViews;
allViews.emplace_back(mDevice, mImages[i], mFormat);
mFrameBuffers.emplace_back(std::make_unique<FrameBuffer>(mDevice, *mRenderPass, std::move(allViews), mWidth, mHeight, 1));
}
}
std::vector<image::image_type> get_images(swapchain_type &swapchain) {
uint32_t count;
VKCHECK(vkGetSwapchainImagesKHR(
internal::get_instance(*internal::get_parent(swapchain)),
internal::get_instance(swapchain), &count, NULL));
std::vector<VkImage> images(count);
VKCHECK(vkGetSwapchainImagesKHR(internal::get_instance(*internal::get_parent(swapchain)), internal::get_instance(swapchain), &count, &images.front()));
std::vector<image::image_type> converted_images;
converted_images.reserve(images.size());
for (VkImage image : images) {
converted_images.push_back(image::image_type(image, internal::get_parent(swapchain), false, VK_IMAGE_TYPE_2D, get_format(swapchain), 1, 1));
}
return std::move(converted_images);
}
void Window::_InitSwapchainImages()
{
_swapchain_images.resize( _swapchain_image_count );
_swapchain_image_views.resize( _swapchain_image_count );
ErrorCheck( vkGetSwapchainImagesKHR( _renderer->GetVulkanDevice(), _swapchain, &_swapchain_image_count, _swapchain_images.data() ) );
for( uint32_t i=0; i < _swapchain_image_count; ++i ) {
VkImageViewCreateInfo image_view_create_info {};
image_view_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
image_view_create_info.image = _swapchain_images[ i ];
image_view_create_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
image_view_create_info.format = _surface_format.format;
image_view_create_info.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
image_view_create_info.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
image_view_create_info.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
image_view_create_info.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
image_view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
image_view_create_info.subresourceRange.baseMipLevel = 0;
image_view_create_info.subresourceRange.levelCount = 1;
image_view_create_info.subresourceRange.baseArrayLayer = 0;
image_view_create_info.subresourceRange.layerCount = 1;
ErrorCheck( vkCreateImageView( _renderer->GetVulkanDevice(), &image_view_create_info, nullptr, &_swapchain_image_views[ i ] ) );
}
}
void Window::_InitSwapchainImages() {
_swapchain_images.resize(_swapchain_image_count);
_swapchain_image_views.resize(_swapchain_image_count);
ErrorCheck(vkGetSwapchainImagesKHR(_renderer->getDevice(), _swapchain, &_swapchain_image_count, _swapchain_images.data()));
for (uint32_t i = 0; i < _swapchain_image_count; i++) {
createImageView(_swapchain_images[i], _surface_format.format, VK_IMAGE_ASPECT_COLOR_BIT, _swapchain_image_views[i]);
}
}
void VulkanWindow::InitializeImageViews()
{
if ( VkResult result = vkGetSwapchainImagesKHR ( mVulkanRenderer.GetDevice(), mVkSwapchainKHR, &mSwapchainImageCount, nullptr ) )
{
std::ostringstream stream;
stream << "Get swapchain image count failed: ( " << GetVulkanResultString ( result ) << " )";
throw std::runtime_error ( stream.str().c_str() );
}
mVkSwapchainImages.resize ( mSwapchainImageCount );
mVkSwapchainImageViews.resize ( mSwapchainImageCount );
if ( VkResult result = vkGetSwapchainImagesKHR ( mVulkanRenderer.GetDevice(),
mVkSwapchainKHR,
&mSwapchainImageCount,
mVkSwapchainImages.data() ) )
{
std::ostringstream stream;
stream << "Get swapchain images failed: ( " << GetVulkanResultString ( result ) << " )";
throw std::runtime_error ( stream.str().c_str() );
}
for ( uint32_t i = 0; i < mSwapchainImageCount; ++i )
{
VkImageViewCreateInfo image_view_create_info{};
image_view_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
image_view_create_info.pNext = nullptr;
image_view_create_info.flags = 0;
image_view_create_info.image = mVkSwapchainImages[i];
image_view_create_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
image_view_create_info.format = mVulkanRenderer.GetSurfaceFormatKHR().format;
image_view_create_info.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
image_view_create_info.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
image_view_create_info.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
image_view_create_info.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
image_view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
image_view_create_info.subresourceRange.baseMipLevel = 0;
image_view_create_info.subresourceRange.levelCount = 1;
image_view_create_info.subresourceRange.baseArrayLayer = 0;
image_view_create_info.subresourceRange.layerCount = 1;
vkCreateImageView ( mVulkanRenderer.GetDevice(), &image_view_create_info, nullptr, &mVkSwapchainImageViews[i] );
}
}
void Window::_InitSwapchain()
{
// This code is old and the fixed one is below
// if( _swapchain_image_count > _surface_capabilities.maxImageCount ) _swapchain_image_count = _surface_capabilities.maxImageCount;
// if( _swapchain_image_count < _surface_capabilities.minImageCount + 1 ) _swapchain_image_count = _surface_capabilities.minImageCount + 1;
// The code above will work just fine in our tutorials and likely on every possible implementation of vulkan as well
// so this change isn't that important. Just to be absolutely sure we don't go over or below the given limits we should check this a
// little bit different though. maxImageCount can actually be zero in which case the amount of swapchain images do not have an
// upper limit other than available memory. It's also possible that the swapchain image amount is locked to a certain
// value on certain systems. The code below takes into consideration both of these possibilities.
if( _swapchain_image_count < _surface_capabilities.minImageCount + 1 ) _swapchain_image_count = _surface_capabilities.minImageCount + 1;
if( _surface_capabilities.maxImageCount > 0 ) {
if( _swapchain_image_count > _surface_capabilities.maxImageCount ) _swapchain_image_count = _surface_capabilities.maxImageCount;
}
VkPresentModeKHR present_mode = VK_PRESENT_MODE_FIFO_KHR;
{
uint32_t present_mode_count = 0;
ErrorCheck( vkGetPhysicalDeviceSurfacePresentModesKHR( _renderer->GetVulkanPhysicalDevice(), _surface, &present_mode_count, nullptr ) );
std::vector<VkPresentModeKHR> present_mode_list( present_mode_count );
ErrorCheck( vkGetPhysicalDeviceSurfacePresentModesKHR( _renderer->GetVulkanPhysicalDevice(), _surface, &present_mode_count, present_mode_list.data() ) );
for( auto m : present_mode_list ) {
if( m == VK_PRESENT_MODE_MAILBOX_KHR ) present_mode = m;
}
}
VkSwapchainCreateInfoKHR swapchain_create_info {};
swapchain_create_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
swapchain_create_info.surface = _surface;
swapchain_create_info.minImageCount = _swapchain_image_count;
swapchain_create_info.imageFormat = _surface_format.format;
swapchain_create_info.imageColorSpace = _surface_format.colorSpace;
swapchain_create_info.imageExtent.width = _surface_size_x;
swapchain_create_info.imageExtent.height = _surface_size_y;
swapchain_create_info.imageArrayLayers = 1;
swapchain_create_info.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
swapchain_create_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
swapchain_create_info.queueFamilyIndexCount = 0;
swapchain_create_info.pQueueFamilyIndices = nullptr;
swapchain_create_info.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
swapchain_create_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
swapchain_create_info.presentMode = present_mode;
swapchain_create_info.clipped = VK_TRUE;
swapchain_create_info.oldSwapchain = VK_NULL_HANDLE;
ErrorCheck( vkCreateSwapchainKHR( _renderer->GetVulkanDevice(), &swapchain_create_info, nullptr, &_swapchain ) );
ErrorCheck( vkGetSwapchainImagesKHR( _renderer->GetVulkanDevice(), _swapchain, &_swapchain_image_count, nullptr ) );
}
void Window::_InitSwapchain() {
if (_swapchain_image_count < _surface_capabilities.minImageCount)
_swapchain_image_count = _surface_capabilities.minImageCount + 1;
if (_swapchain_image_count > _surface_capabilities.maxImageCount)
_swapchain_image_count = _surface_capabilities.maxImageCount;
VkPresentModeKHR present_mode = VK_PRESENT_MODE_FIFO_KHR;
{
uint32_t present_mode_count = 0;
ErrorCheck(vkGetPhysicalDeviceSurfacePresentModesKHR(_renderer->getPhysicalDevice(), _surface, &present_mode_count, nullptr));
std::vector<VkPresentModeKHR> present_mode_list(present_mode_count);
ErrorCheck(vkGetPhysicalDeviceSurfacePresentModesKHR(_renderer->getPhysicalDevice(), _surface, &present_mode_count, present_mode_list.data()));
for (auto m : present_mode_list) {
if (m == VK_PRESENT_MODE_MAILBOX_KHR)
present_mode = m;
}
}
VkSwapchainCreateInfoKHR swapchain_create_info {};
swapchain_create_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
swapchain_create_info.surface = _surface;
swapchain_create_info.minImageCount = _swapchain_image_count; // Buffers
swapchain_create_info.imageFormat = _surface_format.format;
swapchain_create_info.imageColorSpace = _surface_format.colorSpace;
swapchain_create_info.imageExtent.width = _surface_size_x;
swapchain_create_info.imageExtent.height = _surface_size_y;
swapchain_create_info.imageArrayLayers = 1; // Number of images (mono, stereo)
swapchain_create_info.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
swapchain_create_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
swapchain_create_info.queueFamilyIndexCount = 0;
swapchain_create_info.pQueueFamilyIndices = nullptr;
swapchain_create_info.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
swapchain_create_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
swapchain_create_info.presentMode = present_mode;
swapchain_create_info.clipped = VK_TRUE;
swapchain_create_info.oldSwapchain = VK_NULL_HANDLE;
ErrorCheck(vkCreateSwapchainKHR(_renderer->getDevice(), &swapchain_create_info, nullptr, &_swapchain));
ErrorCheck(vkGetSwapchainImagesKHR(_renderer->getDevice(), _swapchain, &_swapchain_image_count, nullptr));
}
int main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
struct sample_info info = {};
char sample_title[] = "Swapchain Initialization Sample";
/*
* Set up swapchain:
* - Get supported uses for all queues
* - Try to find a queue that supports both graphics and present
* - If no queue supports both, find a present queue and make sure we have a
* graphics queue
* - Get a list of supported formats and use the first one
* - Get surface properties and present modes and use them to create a swap
* chain
* - Create swap chain buffers
* - For each buffer, create a color attachment view and set its layout to
* color attachment
*/
init_global_layer_properties(info);
init_instance_extension_names(info);
init_device_extension_names(info);
init_instance(info, sample_title);
init_enumerate_device(info);
init_connection(info);
init_window_size(info, 50, 50);
init_window(info);
/* VULKAN_KEY_START */
// Construct the surface description:
#ifdef _WIN32
VkWin32SurfaceCreateInfoKHR createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
createInfo.pNext = NULL;
createInfo.hinstance = info.connection;
createInfo.hwnd = info.window;
res = vkCreateWin32SurfaceKHR(info.inst, &createInfo, NULL, &info.surface);
#else // _WIN32
VkXcbSurfaceCreateInfoKHR createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
createInfo.pNext = NULL;
createInfo.connection = info.connection;
createInfo.window = info.window;
res = vkCreateXcbSurfaceKHR(info.inst, &createInfo, NULL, &info.surface);
#endif // _WIN32
assert(res == VK_SUCCESS);
// Iterate over each queue to learn whether it supports presenting:
VkBool32 *supportsPresent =
(VkBool32 *)malloc(info.queue_count * sizeof(VkBool32));
for (uint32_t i = 0; i < info.queue_count; i++) {
vkGetPhysicalDeviceSurfaceSupportKHR(info.gpus[0], i, info.surface,
&supportsPresent[i]);
}
// Search for a graphics queue and a present queue in the array of queue
// families, try to find one that supports both
uint32_t graphicsQueueNodeIndex = UINT32_MAX;
for (uint32_t i = 0; i < info.queue_count; i++) {
if ((info.queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) != 0) {
if (supportsPresent[i] == VK_TRUE) {
graphicsQueueNodeIndex = i;
break;
}
}
}
free(supportsPresent);
// Generate error if could not find a queue that supports both a graphics
// and present
if (graphicsQueueNodeIndex == UINT32_MAX) {
std::cout << "Could not find a queue that supports both graphics and "
"present\n";
exit(-1);
}
info.graphics_queue_family_index = graphicsQueueNodeIndex;
init_device(info);
// Get the list of VkFormats that are supported:
uint32_t formatCount;
res = vkGetPhysicalDeviceSurfaceFormatsKHR(info.gpus[0], info.surface,
&formatCount, NULL);
assert(res == VK_SUCCESS);
VkSurfaceFormatKHR *surfFormats =
(VkSurfaceFormatKHR *)malloc(formatCount * sizeof(VkSurfaceFormatKHR));
res = vkGetPhysicalDeviceSurfaceFormatsKHR(info.gpus[0], info.surface,
&formatCount, surfFormats);
assert(res == VK_SUCCESS);
// If the format list includes just one entry of VK_FORMAT_UNDEFINED,
// the surface has no preferred format. Otherwise, at least one
// supported format will be returned.
if (formatCount == 1 && surfFormats[0].format == VK_FORMAT_UNDEFINED) {
info.format = VK_FORMAT_B8G8R8A8_UNORM;
} else {
assert(formatCount >= 1);
info.format = surfFormats[0].format;
}
VkSurfaceCapabilitiesKHR surfCapabilities;
res = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(info.gpus[0], info.surface,
&surfCapabilities);
assert(res == VK_SUCCESS);
uint32_t presentModeCount;
res = vkGetPhysicalDeviceSurfacePresentModesKHR(info.gpus[0], info.surface,
&presentModeCount, NULL);
assert(res == VK_SUCCESS);
VkPresentModeKHR *presentModes =
(VkPresentModeKHR *)malloc(presentModeCount * sizeof(VkPresentModeKHR));
res = vkGetPhysicalDeviceSurfacePresentModesKHR(
info.gpus[0], info.surface, &presentModeCount, presentModes);
assert(res == VK_SUCCESS);
VkExtent2D swapChainExtent;
// width and height are either both -1, or both not -1.
if (surfCapabilities.currentExtent.width == (uint32_t)-1) {
// If the surface size is undefined, the size is set to
// the size of the images requested.
swapChainExtent.width = info.width;
swapChainExtent.height = info.height;
} else {
// If the surface size is defined, the swap chain size must match
swapChainExtent = surfCapabilities.currentExtent;
}
// If mailbox mode is available, use it, as is the lowest-latency non-
// tearing mode. If not, try IMMEDIATE which will usually be available,
// and is fastest (though it tears). If not, fall back to FIFO which is
// always available.
VkPresentModeKHR swapchainPresentMode = VK_PRESENT_MODE_FIFO_KHR;
for (size_t i = 0; i < presentModeCount; i++) {
if (presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR) {
swapchainPresentMode = VK_PRESENT_MODE_MAILBOX_KHR;
break;
}
if ((swapchainPresentMode != VK_PRESENT_MODE_MAILBOX_KHR) &&
(presentModes[i] == VK_PRESENT_MODE_IMMEDIATE_KHR)) {
swapchainPresentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
}
}
// Determine the number of VkImage's to use in the swap chain (we desire to
// own only 1 image at a time, besides the images being displayed and
// queued for display):
uint32_t desiredNumberOfSwapChainImages =
surfCapabilities.minImageCount + 1;
if ((surfCapabilities.maxImageCount > 0) &&
(desiredNumberOfSwapChainImages > surfCapabilities.maxImageCount)) {
// Application must settle for fewer images than desired:
desiredNumberOfSwapChainImages = surfCapabilities.maxImageCount;
}
VkSurfaceTransformFlagBitsKHR preTransform;
if (surfCapabilities.supportedTransforms &
VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) {
preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
} else {
preTransform = surfCapabilities.currentTransform;
}
VkSwapchainCreateInfoKHR swap_chain = {};
swap_chain.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
swap_chain.pNext = NULL;
swap_chain.surface = info.surface;
swap_chain.minImageCount = desiredNumberOfSwapChainImages;
swap_chain.imageFormat = info.format;
swap_chain.imageExtent.width = swapChainExtent.width;
swap_chain.imageExtent.height = swapChainExtent.height;
swap_chain.preTransform = preTransform;
swap_chain.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
swap_chain.imageArrayLayers = 1;
swap_chain.presentMode = swapchainPresentMode;
swap_chain.oldSwapchain = NULL;
swap_chain.clipped = true;
swap_chain.imageColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
swap_chain.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
swap_chain.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
swap_chain.queueFamilyIndexCount = 0;
swap_chain.pQueueFamilyIndices = NULL;
res =
vkCreateSwapchainKHR(info.device, &swap_chain, NULL, &info.swap_chain);
assert(res == VK_SUCCESS);
res = vkGetSwapchainImagesKHR(info.device, info.swap_chain,
&info.swapchainImageCount, NULL);
assert(res == VK_SUCCESS);
VkImage *swapchainImages =
(VkImage *)malloc(info.swapchainImageCount * sizeof(VkImage));
assert(swapchainImages);
res = vkGetSwapchainImagesKHR(info.device, info.swap_chain,
&info.swapchainImageCount, swapchainImages);
assert(res == VK_SUCCESS);
info.buffers.resize(info.swapchainImageCount);
// Going to need a command buffer to send the memory barriers in
// set_image_layout but we couldn't have created one before we knew
// what our graphics_queue_family_index is, but now that we have it,
// create the command buffer
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
vkGetDeviceQueue(info.device, info.graphics_queue_family_index, 0,
&info.queue);
for (uint32_t i = 0; i < info.swapchainImageCount; i++) {
VkImageViewCreateInfo color_image_view = {};
color_image_view.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
color_image_view.pNext = NULL;
color_image_view.format = info.format;
color_image_view.components.r = VK_COMPONENT_SWIZZLE_R;
color_image_view.components.g = VK_COMPONENT_SWIZZLE_G;
color_image_view.components.b = VK_COMPONENT_SWIZZLE_B;
color_image_view.components.a = VK_COMPONENT_SWIZZLE_A;
color_image_view.subresourceRange.aspectMask =
VK_IMAGE_ASPECT_COLOR_BIT;
color_image_view.subresourceRange.baseMipLevel = 0;
color_image_view.subresourceRange.levelCount = 1;
color_image_view.subresourceRange.baseArrayLayer = 0;
color_image_view.subresourceRange.layerCount = 1;
color_image_view.viewType = VK_IMAGE_VIEW_TYPE_2D;
color_image_view.flags = 0;
info.buffers[i].image = swapchainImages[i];
set_image_layout(info, info.buffers[i].image, VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
color_image_view.image = info.buffers[i].image;
res = vkCreateImageView(info.device, &color_image_view, NULL,
&info.buffers[i].view);
assert(res == VK_SUCCESS);
}
free(swapchainImages);
execute_end_command_buffer(info);
execute_queue_command_buffer(info);
/* VULKAN_KEY_END */
/* Clean Up */
VkCommandBuffer cmd_bufs[1] = {info.cmd};
vkFreeCommandBuffers(info.device, info.cmd_pool, 1, cmd_bufs);
vkDestroyCommandPool(info.device, info.cmd_pool, NULL);
for (uint32_t i = 0; i < info.swapchainImageCount; i++) {
vkDestroyImageView(info.device, info.buffers[i].view, NULL);
}
vkDestroySwapchainKHR(info.device, info.swap_chain, NULL);
destroy_device(info);
destroy_window(info);
destroy_instance(info);
return 0;
}
bool initSwapChains()
{
std::cout << "initing swapchain...";
if( !getSurfaceFormats() || !getSurfacePresentModes() )
{
return false;
}
VkResult res;
res = vkGetPhysicalDeviceSurfaceCapabilitiesKHR( gDevices[0], gSurface, &gSurfaceCaps );
if( res != VK_SUCCESS )
{
std::cout << "error getting surface capabilities\n";
}
VkExtent2D swapChainExtent = gSurfaceCaps.currentExtent;
if( std::find( gPresentModes.begin(), gPresentModes.end(), VK_PRESENT_MODE_MAILBOX_KHR ) != gPresentModes.end() )
gPresentMode = VK_PRESENT_MODE_MAILBOX_KHR;
else if( std::find( gPresentModes.begin(), gPresentModes.end(), VK_PRESENT_MODE_IMMEDIATE_KHR ) != gPresentModes.end() )
gPresentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
else
gPresentMode = VK_PRESENT_MODE_FIFO_KHR;
uint32_t desiredNumberOfSwapChainImages = gSurfaceCaps.minImageCount + 1;
desiredNumberOfSwapChainImages = gSurfaceCaps.maxImageCount ? max( desiredNumberOfSwapChainImages, gSurfaceCaps.maxImageCount ) : desiredNumberOfSwapChainImages;
VkSurfaceTransformFlagBitsKHR preTransform;
preTransform = gSurfaceCaps.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR ? VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR : gSurfaceCaps.currentTransform;
VkSwapchainCreateInfoKHR swapChain = {};
swapChain.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
swapChain.pNext = nullptr;
swapChain.surface = gSurface;
swapChain.minImageCount = desiredNumberOfSwapChainImages;
swapChain.imageFormat = gFormat;
swapChain.imageExtent = swapChainExtent;
swapChain.preTransform = preTransform;
swapChain.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
swapChain.imageArrayLayers = 1;
swapChain.presentMode = gPresentMode;
swapChain.oldSwapchain = NULL;
swapChain.clipped = true;
swapChain.imageColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
swapChain.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
swapChain.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
swapChain.queueFamilyIndexCount = 0;
swapChain.pQueueFamilyIndices = nullptr;
res = vkCreateSwapchainKHR( gDevice, &swapChain, nullptr, &gSwapchain );
if( res != VK_SUCCESS )
{
std::cout << "error creating swapchain "<< res << std::endl;
return false;
}
std::vector<VkImage> images;
u32 imagesCount = 0;
HR( vkGetSwapchainImagesKHR(gDevice, gSwapchain, &imagesCount, nullptr ) );
images.resize( imagesCount );
HR( vkGetSwapchainImagesKHR(gDevice, gSwapchain, &imagesCount, images.data() ) );
beginCommandBuffer( gCmd );
vkGetDeviceQueue( gDevice, gQueueFamilyIndex, 0, &gQueue );
gSwapBuffers.resize( imagesCount );
for( u32 i = 0; i < gSwapBuffers.size(); ++i )
{
VkImageViewCreateInfo imageView = {};
imageView.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
imageView.pNext = nullptr;
imageView.format = gFormat;
imageView.components.r = VK_COMPONENT_SWIZZLE_R;
imageView.components.g = VK_COMPONENT_SWIZZLE_G;
imageView.components.b = VK_COMPONENT_SWIZZLE_B;
imageView.components.a = VK_COMPONENT_SWIZZLE_A;
imageView.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageView.subresourceRange.baseMipLevel = 0;
imageView.subresourceRange.levelCount = 1;
imageView.subresourceRange.baseArrayLayer = 0;
imageView.subresourceRange.layerCount = 1;
imageView.viewType = VK_IMAGE_VIEW_TYPE_2D;
imageView.flags = 0;
imageView.image = images[i];
setImageLayout( gCmd, gSwapBuffers[i].image, VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL );
HR( vkCreateImageView( gDevice, &imageView, nullptr, &gSwapBuffers[i].view ) );
}
endCommandBuffer( gCmd );
executeQueue( gCmd );
std::cout << "inited\n";
return true;
}
//==============================================================================
// Vulkan初期化
//==============================================================================
bool initVulkan(HINSTANCE hinst, HWND wnd)
{
VkResult result;
//==================================================
// Vulkanのインスタンス作成
//==================================================
VkApplicationInfo applicationInfo = {};
applicationInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
applicationInfo.pApplicationName = APPLICATION_NAME;
applicationInfo.pEngineName = APPLICATION_NAME;
applicationInfo.apiVersion = VK_MAKE_VERSION(1, 0, 0);
std::vector<LPCSTR> enabledExtensionsByInstance = { VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WIN32_SURFACE_EXTENSION_NAME };
VkInstanceCreateInfo instanceCreateInfo = {};
instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceCreateInfo.pNext = nullptr;
instanceCreateInfo.pApplicationInfo = &applicationInfo;
if(enabledExtensionsByInstance.empty() == false)
{
instanceCreateInfo.enabledExtensionCount = enabledExtensionsByInstance.size();
instanceCreateInfo.ppEnabledExtensionNames = enabledExtensionsByInstance.data();
}
result = vkCreateInstance(&instanceCreateInfo, nullptr, &g_VulkanInstance);
checkVulkanError(result, TEXT("Vulkanインスタンス作成失敗"));
//==================================================
// 物理デバイス(GPUデバイス)
//==================================================
// 物理デバイス数を獲得
uint32_t gpuCount = 0;
vkEnumeratePhysicalDevices(g_VulkanInstance, &gpuCount, nullptr);
assert(gpuCount > 0 && TEXT("物理デバイス数の獲得失敗"));
// 物理デバイス数を列挙
std::vector<VkPhysicalDevice> physicalDevices(gpuCount);
result = vkEnumeratePhysicalDevices(g_VulkanInstance, &gpuCount, physicalDevices.data());
checkVulkanError(result, TEXT("物理デバイスの列挙に失敗しました"));
// すべてのGPU情報を格納
g_GPUs.resize(gpuCount);
for(uint32_t i = 0; i < gpuCount; ++i)
{
g_GPUs[i].device = physicalDevices[i];
// 物理デバイスのプロパティ獲得
vkGetPhysicalDeviceProperties(g_GPUs[i].device, &g_GPUs[i].deviceProperties);
// 物理デバイスのメモリプロパティ獲得
vkGetPhysicalDeviceMemoryProperties(g_GPUs[i].device, &g_GPUs[i].deviceMemoryProperties);
}
// ※このサンプルでは最初に列挙されたGPUデバイスを使用する
g_currentGPU = g_GPUs[0];
// グラフィックス操作をサポートするキューを検索
uint32_t queueCount;
vkGetPhysicalDeviceQueueFamilyProperties(g_currentGPU.device, &queueCount, nullptr);
assert(queueCount >= 1 && TEXT("物理デバイスキューの検索失敗"));
std::vector<VkQueueFamilyProperties> queueProps;
queueProps.resize(queueCount);
vkGetPhysicalDeviceQueueFamilyProperties(g_currentGPU.device, &queueCount, queueProps.data());
uint32_t graphicsQueueIndex = 0;
for(graphicsQueueIndex = 0; graphicsQueueIndex < queueCount; ++graphicsQueueIndex)
{
if(queueProps[graphicsQueueIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT)
{
break;
}
}
assert(graphicsQueueIndex < queueCount && TEXT("グラフィックスをサポートするキューを見つけられませんでした"));
//==================================================
// Vulkanデバイス作成
//==================================================
float queuePrioritie = 0.0f;
VkDeviceQueueCreateInfo queueCreateInfo = {};
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo.queueFamilyIndex = graphicsQueueIndex;
queueCreateInfo.queueCount = 1;
queueCreateInfo.pQueuePriorities = &queuePrioritie;
std::vector<LPCSTR> enabledExtensionsByDevice = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
VkDeviceCreateInfo deviceCreateInfo = {};
deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
deviceCreateInfo.pNext = nullptr;
deviceCreateInfo.queueCreateInfoCount = 1;
deviceCreateInfo.pQueueCreateInfos = &queueCreateInfo;
deviceCreateInfo.pEnabledFeatures = nullptr;
if(enabledExtensionsByDevice.empty() == false)
{
deviceCreateInfo.enabledExtensionCount = enabledExtensionsByDevice.size();
deviceCreateInfo.ppEnabledExtensionNames = enabledExtensionsByDevice.data();
}
result = vkCreateDevice(g_currentGPU.device, &deviceCreateInfo, nullptr, &g_VulkanDevice);
checkVulkanError(result, TEXT("Vulkanデバイス作成失敗"));
// グラフィックスキュー獲得
vkGetDeviceQueue(g_VulkanDevice, graphicsQueueIndex, 0, &g_VulkanQueue);
//==================================================
// フェンスオブジェクト作成
//==================================================
VkFenceCreateInfo fenceCreateInfo = {};
fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceCreateInfo.pNext = nullptr;
fenceCreateInfo.flags = 0;
result = vkCreateFence(g_VulkanDevice, &fenceCreateInfo, nullptr, &g_VulkanFence);
checkVulkanError(result, TEXT("フェンスオブジェクト作成失敗"));
//==================================================
// 同期（セマフォ）オブジェクト作成
//==================================================
VkSemaphoreCreateInfo semaphoreCreateInfo = {};
semaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
semaphoreCreateInfo.pNext = nullptr;
semaphoreCreateInfo.flags = 0;
// コマンドバッファ実行用セマフォ作成
result = vkCreateSemaphore(g_VulkanDevice, &semaphoreCreateInfo, nullptr, &g_VulkanSemahoreRenderComplete);
checkVulkanError(result, TEXT("コマンドバッファ実行用セマフォ作成失敗"));
//==================================================
// コマンドプール作製
//==================================================
VkCommandPoolCreateInfo cmdPoolInfo = {};
cmdPoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
cmdPoolInfo.queueFamilyIndex = 0;
cmdPoolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
result = vkCreateCommandPool(g_VulkanDevice, &cmdPoolInfo, nullptr, &g_VulkanCommandPool);
checkVulkanError(result, TEXT("コマンドプール作成失敗"));
//==================================================
// コマンドバッファ作成
//==================================================
// メモリを確保.
g_commandBuffers.resize(SWAP_CHAIN_COUNT);
VkCommandBufferAllocateInfo commandBufferAllocateInfo = {};
commandBufferAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
commandBufferAllocateInfo.pNext = nullptr;
commandBufferAllocateInfo.commandPool = g_VulkanCommandPool;
commandBufferAllocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
commandBufferAllocateInfo.commandBufferCount = SWAP_CHAIN_COUNT;
result = vkAllocateCommandBuffers(g_VulkanDevice, &commandBufferAllocateInfo, g_commandBuffers.data());
checkVulkanError(result, TEXT("コマンドバッファ作成失敗"));
//==================================================
// OS(今回はWin32)用のサーフェスを作成する
//==================================================
VkWin32SurfaceCreateInfoKHR surfaceCreateInfo = {};
surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
surfaceCreateInfo.hinstance = hinst;
surfaceCreateInfo.hwnd = wnd;
result = vkCreateWin32SurfaceKHR(g_VulkanInstance, &surfaceCreateInfo, nullptr, &g_VulkanSurface);
checkVulkanError(result, TEXT("サーフェス作成失敗"));
//==================================================
// スワップチェーンを作成する
//==================================================
VkFormat imageFormat = VK_FORMAT_R8G8B8A8_UNORM;
VkColorSpaceKHR imageColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
uint32_t surfaceFormatCount = 0;
result = vkGetPhysicalDeviceSurfaceFormatsKHR(g_currentGPU.device, g_VulkanSurface, &surfaceFormatCount, nullptr);
checkVulkanError(result, TEXT("サポートしているカラーフォーマット数の獲得失敗"));
std::vector<VkSurfaceFormatKHR> surfaceFormats;
surfaceFormats.resize(surfaceFormatCount);
result = vkGetPhysicalDeviceSurfaceFormatsKHR(g_currentGPU.device, g_VulkanSurface, &surfaceFormatCount, surfaceFormats.data());
checkVulkanError(result, TEXT("サポートしているカラーフォーマットの獲得失敗"));
// 一致するカラーフォーマットを検索する
bool isFind = false;
for(const auto& surfaceFormat : surfaceFormats)
{
if(imageFormat == surfaceFormat.format &&
imageColorSpace == surfaceFormat.colorSpace)
{
isFind = true;
break;
}
}
if(isFind == false)
{
imageFormat = surfaceFormats[0].format;
imageColorSpace = surfaceFormats[0].colorSpace;
}
// サーフェスの機能を獲得する
VkSurfaceCapabilitiesKHR surfaceCapabilities;
VkSurfaceTransformFlagBitsKHR surfaceTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
g_currentGPU.device,
g_VulkanSurface,
&surfaceCapabilities);
checkVulkanError(result, TEXT("サーフェスの機能の獲得失敗"));
if((surfaceCapabilities.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) == 0)
{
surfaceTransform = surfaceCapabilities.currentTransform;
}
// プレゼント機能を獲得する
VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;
uint32_t presentModeCount;
result = vkGetPhysicalDeviceSurfacePresentModesKHR(
g_currentGPU.device,
g_VulkanSurface,
&presentModeCount,
nullptr);
checkVulkanError(result, TEXT("プレゼント機能数の獲得失敗"));
std::vector<VkPresentModeKHR> presentModes;
presentModes.resize(presentModeCount);
result = vkGetPhysicalDeviceSurfacePresentModesKHR(
g_currentGPU.device,
g_VulkanSurface,
&presentModeCount,
presentModes.data());
checkVulkanError(result, TEXT("プレゼント機能の獲得失敗"));
for(const auto& presentModeInfo : presentModes)
{
if(presentModeInfo == VK_PRESENT_MODE_MAILBOX_KHR)
{
presentMode = VK_PRESENT_MODE_MAILBOX_KHR;
break;
}
if(presentModeInfo == VK_PRESENT_MODE_IMMEDIATE_KHR)
{
presentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
}
}
presentModes.clear();
uint32_t desiredSwapChainImageCount = surfaceCapabilities.minImageCount + 1;
if(surfaceCapabilities.maxImageCount > 0 && desiredSwapChainImageCount > surfaceCapabilities.maxImageCount)
{
desiredSwapChainImageCount = surfaceCapabilities.maxImageCount;
}
// スワップチェーン作成
VkSwapchainCreateInfoKHR swapchainCreateInfo = {};
swapchainCreateInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
swapchainCreateInfo.pNext = nullptr;
swapchainCreateInfo.flags = 0;
swapchainCreateInfo.surface = g_VulkanSurface;
swapchainCreateInfo.minImageCount = desiredSwapChainImageCount;
swapchainCreateInfo.imageFormat = imageFormat;
swapchainCreateInfo.imageColorSpace = imageColorSpace;
swapchainCreateInfo.imageExtent = { SCREEN_WIDTH, SCREEN_HEIGHT };
swapchainCreateInfo.imageArrayLayers = 1;
swapchainCreateInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
swapchainCreateInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
swapchainCreateInfo.queueFamilyIndexCount = 0;
swapchainCreateInfo.pQueueFamilyIndices = nullptr;
swapchainCreateInfo.preTransform = surfaceTransform;
swapchainCreateInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
swapchainCreateInfo.presentMode = presentMode;
swapchainCreateInfo.clipped = VK_TRUE;
swapchainCreateInfo.oldSwapchain = VK_NULL_HANDLE;
result = vkCreateSwapchainKHR(g_VulkanDevice, &swapchainCreateInfo, nullptr, &g_VulkanSwapChain);
checkVulkanError(result, TEXT("サーフェス作成失敗"));
//==================================================
// イメージの作成
//==================================================
uint32_t swapChainCount = 0;
result = vkGetSwapchainImagesKHR(g_VulkanDevice, g_VulkanSwapChain, &swapChainCount, nullptr);
checkVulkanError(result, TEXT("スワップチェーンイメージ数の獲得失敗"));
g_backBuffersTextures.resize(swapChainCount);
std::vector<VkImage> images;
images.resize(swapChainCount);
result = vkGetSwapchainImagesKHR(g_VulkanDevice, g_VulkanSwapChain, &swapChainCount, images.data());
checkVulkanError(result, TEXT("スワップチェーンイメージの獲得失敗"));
for(uint32_t i = 0; i < swapChainCount; ++i)
{
g_backBuffersTextures[i].image = images[i];
}
images.clear();
//==================================================
// イメージビューの生成
//==================================================
for(auto& backBuffer : g_backBuffersTextures)
{
VkImageViewCreateInfo imageViewCreateInfo = {};
imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
imageViewCreateInfo.pNext = nullptr;
imageViewCreateInfo.flags = 0;
imageViewCreateInfo.image = backBuffer.image;
imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
imageViewCreateInfo.format = imageFormat;
imageViewCreateInfo.components.r = VK_COMPONENT_SWIZZLE_R;
imageViewCreateInfo.components.g = VK_COMPONENT_SWIZZLE_G;
imageViewCreateInfo.components.b = VK_COMPONENT_SWIZZLE_B;
imageViewCreateInfo.components.a = VK_COMPONENT_SWIZZLE_A;
imageViewCreateInfo.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
result = vkCreateImageView(g_VulkanDevice, &imageViewCreateInfo, nullptr, &backBuffer.view);
checkVulkanError(result, TEXT("イメージビューの作成失敗"));
setImageLayout(
g_VulkanDevice,
g_commandBuffers[g_currentBufferIndex],
backBuffer.image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
}
//==================================================
// 深度ステンシルバッファの生成
//==================================================
VkFormat depthFormat = VK_FORMAT_D24_UNORM_S8_UINT;
VkImageTiling imageTiling;
VkFormatProperties formatProperties;
vkGetPhysicalDeviceFormatProperties(g_currentGPU.device, depthFormat, &formatProperties);
if(formatProperties.linearTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
{
imageTiling = VK_IMAGE_TILING_LINEAR;
}
else if(formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
{
imageTiling = VK_IMAGE_TILING_OPTIMAL;
}
else
{
checkVulkanError(VK_RESULT_MAX_ENUM, TEXT("サポートされていないフォーマットです"));
return false;
}
VkImageCreateInfo imageCreateInfo = {};
imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
imageCreateInfo.pNext = nullptr;
imageCreateInfo.flags = 0;
imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
imageCreateInfo.format = depthFormat;
imageCreateInfo.extent.width = SCREEN_WIDTH;
imageCreateInfo.extent.height = SCREEN_HEIGHT;
imageCreateInfo.extent.depth = 1;
imageCreateInfo.mipLevels = 1;
imageCreateInfo.arrayLayers = 1;
imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
imageCreateInfo.tiling = imageTiling;
imageCreateInfo.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
imageCreateInfo.queueFamilyIndexCount = 0;
imageCreateInfo.pQueueFamilyIndices = nullptr;
imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
result = vkCreateImage(g_VulkanDevice, &imageCreateInfo, nullptr, &g_depthBufferTexture.image);
checkVulkanError(result, TEXT("深度テクスチャ用イメージビュー作成失敗"));
// メモリ要件を獲得
VkMemoryRequirements memoryRequirements;
vkGetImageMemoryRequirements(g_VulkanDevice, g_depthBufferTexture.image, &memoryRequirements);
VkFlags requirementsMask = 0;
uint32_t typeBits = memoryRequirements.memoryTypeBits;
uint32_t typeIndex = 0;
for(const auto& memoryType : g_currentGPU.deviceMemoryProperties.memoryTypes)
{
if((typeBits & 0x1) == 1)
{
if((memoryType.propertyFlags & requirementsMask) == requirementsMask)
{
break;
}
}
typeBits >>= 1;
++typeIndex;
}
// メモリ確保
VkMemoryAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.pNext = nullptr;
allocInfo.allocationSize = memoryRequirements.size;
allocInfo.memoryTypeIndex = typeIndex;
result = vkAllocateMemory(g_VulkanDevice, &allocInfo, nullptr, &g_depthBufferTexture.memory);
checkVulkanError(result, TEXT("深度テクスチャ用メモリ確保失敗"));
result = vkBindImageMemory(g_VulkanDevice, g_depthBufferTexture.image, g_depthBufferTexture.memory, 0);
checkVulkanError(result, TEXT("深度テクスチャメモリにバインド失敗"));
VkImageViewCreateInfo imageViewCreateInfo = {};
imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
imageViewCreateInfo.pNext = nullptr;
imageViewCreateInfo.image = g_depthBufferTexture.image;
imageViewCreateInfo.format = depthFormat;
imageViewCreateInfo.components.r = VK_COMPONENT_SWIZZLE_R;
imageViewCreateInfo.components.g = VK_COMPONENT_SWIZZLE_G;
imageViewCreateInfo.components.b = VK_COMPONENT_SWIZZLE_B;
imageViewCreateInfo.components.a = VK_COMPONENT_SWIZZLE_A;
imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
imageViewCreateInfo.subresourceRange.baseMipLevel = 0;
imageViewCreateInfo.subresourceRange.levelCount = 1;
imageViewCreateInfo.subresourceRange.baseArrayLayer = 0;
imageViewCreateInfo.subresourceRange.layerCount = 1;
imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
imageViewCreateInfo.flags = 0;
result = vkCreateImageView(g_VulkanDevice, &imageViewCreateInfo, nullptr, &g_depthBufferTexture.view);
checkVulkanError(result, TEXT("深度テクスチャイメージビュー作成失敗"));
setImageLayout(
g_VulkanDevice,
g_commandBuffers[g_currentBufferIndex],
g_depthBufferTexture.image,
VK_IMAGE_ASPECT_DEPTH_BIT,
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
//==================================================
// フレームバッファの生成
//==================================================
VkImageView attachments[2]; // 0=カラーバッファ、1=深度バッファ
VkFramebufferCreateInfo frameBufferCreateInfo = {};
frameBufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
frameBufferCreateInfo.pNext = nullptr;
frameBufferCreateInfo.flags = 0;
frameBufferCreateInfo.renderPass = VK_NULL_HANDLE;
frameBufferCreateInfo.attachmentCount = 2;
frameBufferCreateInfo.pAttachments = attachments;
frameBufferCreateInfo.width = SCREEN_WIDTH;
frameBufferCreateInfo.height = SCREEN_HEIGHT;
frameBufferCreateInfo.layers = 1;
g_frameBuffers.resize(SWAP_CHAIN_COUNT);
for(uint32_t i = 0; i < SWAP_CHAIN_COUNT; ++i)
{
attachments[0] = g_backBuffersTextures[i].view;
attachments[1] = g_depthBufferTexture.view;
auto result = vkCreateFramebuffer(g_VulkanDevice, &frameBufferCreateInfo, nullptr, &g_frameBuffers[i]);
checkVulkanError(result, TEXT("フレームバッファ作成失敗"));
}
return true;
}
//[-------------------------------------------------------]
//[ 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);
}
}
void VulkanSwapChain::rebuild(const SPtr<VulkanDevice>& device, VkSurfaceKHR surface, UINT32 width, UINT32 height,
bool vsync, VkFormat colorFormat, VkColorSpaceKHR colorSpace, bool createDepth, VkFormat depthFormat)
{
mDevice = device;
VkResult result;
VkPhysicalDevice physicalDevice = device->getPhysical();
// Determine swap chain dimensions
VkSurfaceCapabilitiesKHR surfaceCaps;
result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, &surfaceCaps);
assert(result == VK_SUCCESS);
VkExtent2D swapchainExtent;
// If width/height is 0xFFFFFFFF, we can manually specify width, height
if (surfaceCaps.currentExtent.width == (uint32_t)-1 || surfaceCaps.currentExtent.height == (uint32_t)-1)
{
swapchainExtent.width = width;
swapchainExtent.height = height;
}
else // Otherwise we must use the size we're given
swapchainExtent = surfaceCaps.currentExtent;
mWidth = swapchainExtent.width;
mHeight = swapchainExtent.height;
// Find present mode
uint32_t numPresentModes;
result = vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, &numPresentModes, nullptr);
assert(result == VK_SUCCESS);
assert(numPresentModes > 0);
VkPresentModeKHR* presentModes = bs_stack_alloc<VkPresentModeKHR>(numPresentModes);
result = vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, &numPresentModes, presentModes);
assert(result == VK_SUCCESS);
VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;
if(!vsync)
{
for (UINT32 i = 0; i < numPresentModes; i++)
{
if (presentModes[i] == VK_PRESENT_MODE_IMMEDIATE_KHR)
{
presentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
break;
}
if (presentModes[i] == VK_PRESENT_MODE_FIFO_RELAXED_KHR)
presentMode = VK_PRESENT_MODE_FIFO_RELAXED_KHR;
}
}
else
{
// Mailbox comes with lower input latency than FIFO, but can waste GPU power by rendering frames that are never
// displayed, especially if the app runs much faster than the refresh rate. This is a concern for mobiles.
#if BS_PLATFORM != BS_PLATFORM_ANDROID && BS_PLATFORM != BS_PLATFORM_IOS
for (UINT32 i = 0; i < numPresentModes; i++)
{
if (presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR)
{
presentMode = VK_PRESENT_MODE_MAILBOX_KHR;
break;
}
}
#endif
}
bs_stack_free(presentModes);
uint32_t numImages = surfaceCaps.minImageCount;
VkSurfaceTransformFlagsKHR transform;
if (surfaceCaps.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR)
transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
else
transform = surfaceCaps.currentTransform;
VkSwapchainCreateInfoKHR swapChainCI;
swapChainCI.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
swapChainCI.pNext = nullptr;
swapChainCI.flags = 0;
swapChainCI.surface = surface;
swapChainCI.minImageCount = numImages;
swapChainCI.imageFormat = colorFormat;
swapChainCI.imageColorSpace = colorSpace;
swapChainCI.imageExtent = { swapchainExtent.width, swapchainExtent.height };
swapChainCI.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
swapChainCI.preTransform = (VkSurfaceTransformFlagBitsKHR)transform;
swapChainCI.imageArrayLayers = 1;
swapChainCI.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
swapChainCI.queueFamilyIndexCount = 0;
swapChainCI.pQueueFamilyIndices = NULL;
swapChainCI.presentMode = presentMode;
swapChainCI.oldSwapchain = mSwapChain;
swapChainCI.clipped = VK_TRUE;
swapChainCI.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
VkSwapchainKHR oldSwapChain = mSwapChain;
VkDevice logicalDevice = device->getLogical();
result = vkCreateSwapchainKHR(logicalDevice, &swapChainCI, gVulkanAllocator, &mSwapChain);
assert(result == VK_SUCCESS);
clear(oldSwapChain);
result = vkGetSwapchainImagesKHR(logicalDevice, mSwapChain, &numImages, nullptr);
assert(result == VK_SUCCESS);
// Get the swap chain images
VkImage* images = bs_stack_alloc<VkImage>(numImages);
result = vkGetSwapchainImagesKHR(logicalDevice, mSwapChain, &numImages, images);
assert(result == VK_SUCCESS);
VulkanResourceManager& resManager = device->getResourceManager();
VULKAN_IMAGE_DESC imageDesc;
imageDesc.format = colorFormat;
imageDesc.type = TEX_TYPE_2D;
imageDesc.usage = TU_RENDERTARGET;
imageDesc.layout = VK_IMAGE_LAYOUT_UNDEFINED;
imageDesc.numFaces = 1;
imageDesc.numMipLevels = 1;
imageDesc.memory = VK_NULL_HANDLE;
mSurfaces.resize(numImages);
for (UINT32 i = 0; i < numImages; i++)
{
imageDesc.image = images[i];
mSurfaces[i].acquired = false;
mSurfaces[i].needsWait = false;
mSurfaces[i].image = resManager.create<VulkanImage>(imageDesc, false);
mSurfaces[i].sync = resManager.create<VulkanSemaphore>();
}
bs_stack_free(images);
// Create depth stencil image
if (createDepth)
{
VkImageCreateInfo depthStencilImageCI;
depthStencilImageCI.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
depthStencilImageCI.pNext = nullptr;
depthStencilImageCI.flags = 0;
depthStencilImageCI.imageType = VK_IMAGE_TYPE_2D;
depthStencilImageCI.format = depthFormat;
depthStencilImageCI.extent = { width, height, 1 };
depthStencilImageCI.mipLevels = 1;
depthStencilImageCI.arrayLayers = 1;
depthStencilImageCI.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
depthStencilImageCI.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
depthStencilImageCI.samples = VK_SAMPLE_COUNT_1_BIT;
depthStencilImageCI.tiling = VK_IMAGE_TILING_OPTIMAL;
depthStencilImageCI.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
depthStencilImageCI.pQueueFamilyIndices = nullptr;
depthStencilImageCI.queueFamilyIndexCount = 0;
VkImage depthStencilImage;
result = vkCreateImage(logicalDevice, &depthStencilImageCI, gVulkanAllocator, &depthStencilImage);
assert(result == VK_SUCCESS);
imageDesc.image = depthStencilImage;
imageDesc.usage = TU_DEPTHSTENCIL;
imageDesc.format = depthFormat;
imageDesc.memory = mDevice->allocateMemory(depthStencilImage, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
mDepthStencilImage = resManager.create<VulkanImage>(imageDesc, true);
}
else
mDepthStencilImage = nullptr;
// Create a framebuffer for each swap chain buffer
UINT32 numFramebuffers = (UINT32)mSurfaces.size();
for (UINT32 i = 0; i < numFramebuffers; i++)
{
VULKAN_FRAMEBUFFER_DESC& desc = mSurfaces[i].framebufferDesc;
desc.width = getWidth();
desc.height = getHeight();
desc.layers = 1;
desc.numSamples = 1;
desc.offscreen = false;
desc.color[0].format = colorFormat;
desc.color[0].image = mSurfaces[i].image;
desc.color[0].surface = TextureSurface::COMPLETE;
desc.color[0].baseLayer = 0;
desc.depth.format = depthFormat;
desc.depth.image = mDepthStencilImage;
desc.depth.surface = TextureSurface::COMPLETE;
desc.depth.baseLayer = 0;
mSurfaces[i].framebuffer = resManager.create<VulkanFramebuffer>(desc);
}
}
static void resize_vulkan(GLFWwindow* /*window*/, int w, int h)
{
VkResult err;
VkSwapchainKHR old_swapchain = g_Swapchain;
err = vkDeviceWaitIdle(g_Device);
check_vk_result(err);
// Destroy old Framebuffer:
for (uint32_t i = 0; i < g_BackBufferCount; i++)
if (g_BackBufferView[i])
vkDestroyImageView(g_Device, g_BackBufferView[i], g_Allocator);
for (uint32_t i = 0; i < g_BackBufferCount; i++)
if (g_Framebuffer[i])
vkDestroyFramebuffer(g_Device, g_Framebuffer[i], g_Allocator);
if (g_RenderPass)
vkDestroyRenderPass(g_Device, g_RenderPass, g_Allocator);
// Create Swapchain:
{
VkSwapchainCreateInfoKHR info = {};
info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
info.surface = g_Surface;
info.imageFormat = g_SurfaceFormat.format;
info.imageColorSpace = g_SurfaceFormat.colorSpace;
info.imageArrayLayers = 1;
info.imageUsage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
info.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
info.presentMode = g_PresentMode;
info.clipped = VK_TRUE;
info.oldSwapchain = old_swapchain;
VkSurfaceCapabilitiesKHR cap;
err = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(g_Gpu, g_Surface, &cap);
check_vk_result(err);
if (cap.maxImageCount > 0)
info.minImageCount = (cap.minImageCount + 2 < cap.maxImageCount) ? (cap.minImageCount + 2) : cap.maxImageCount;
else
info.minImageCount = cap.minImageCount + 2;
if (cap.currentExtent.width == 0xffffffff)
{
fb_width = w;
fb_height = h;
info.imageExtent.width = fb_width;
info.imageExtent.height = fb_height;
}
else
{
fb_width = cap.currentExtent.width;
fb_height = cap.currentExtent.height;
info.imageExtent.width = fb_width;
info.imageExtent.height = fb_height;
}
err = vkCreateSwapchainKHR(g_Device, &info, g_Allocator, &g_Swapchain);
check_vk_result(err);
err = vkGetSwapchainImagesKHR(g_Device, g_Swapchain, &g_BackBufferCount, NULL);
check_vk_result(err);
err = vkGetSwapchainImagesKHR(g_Device, g_Swapchain, &g_BackBufferCount, g_BackBuffer);
check_vk_result(err);
}
if (old_swapchain)
vkDestroySwapchainKHR(g_Device, old_swapchain, g_Allocator);
// Create the Render Pass:
{
VkAttachmentDescription attachment = {};
attachment.format = g_SurfaceFormat.format;
attachment.samples = VK_SAMPLE_COUNT_1_BIT;
attachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
attachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
attachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
VkAttachmentReference color_attachment = {};
color_attachment.attachment = 0;
color_attachment.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass = {};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &color_attachment;
VkRenderPassCreateInfo info = {};
info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
info.attachmentCount = 1;
info.pAttachments = &attachment;
info.subpassCount = 1;
info.pSubpasses = &subpass;
err = vkCreateRenderPass(g_Device, &info, g_Allocator, &g_RenderPass);
check_vk_result(err);
}
// Create The Image Views
{
VkImageViewCreateInfo info = {};
info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
info.viewType = VK_IMAGE_VIEW_TYPE_2D;
info.format = g_SurfaceFormat.format;
info.components.r = VK_COMPONENT_SWIZZLE_R;
info.components.g = VK_COMPONENT_SWIZZLE_G;
info.components.b = VK_COMPONENT_SWIZZLE_B;
info.components.a = VK_COMPONENT_SWIZZLE_A;
info.subresourceRange = g_ImageRange;
for (uint32_t i = 0; i < g_BackBufferCount; i++)
{
info.image = g_BackBuffer[i];
err = vkCreateImageView(g_Device, &info, g_Allocator, &g_BackBufferView[i]);
check_vk_result(err);
}
}
// Create Framebuffer:
{
VkImageView attachment[1];
VkFramebufferCreateInfo info = {};
info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
info.renderPass = g_RenderPass;
info.attachmentCount = 1;
info.pAttachments = attachment;
info.width = fb_width;
info.height = fb_height;
info.layers = 1;
for (uint32_t i = 0; i < g_BackBufferCount; i++)
{
attachment[0] = g_BackBufferView[i];
err = vkCreateFramebuffer(g_Device, &info, g_Allocator, &g_Framebuffer[i]);
check_vk_result(err);
}
}
}
VkResult WrappedVulkan::vkCreateSwapchainKHR(
VkDevice device,
const VkSwapchainCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSwapchainKHR* pSwapChain)
{
VkSwapchainCreateInfoKHR createInfo = *pCreateInfo;
// make sure we can readback to get the screenshot
createInfo.imageUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
createInfo.surface = Unwrap(createInfo.surface);
createInfo.oldSwapchain = Unwrap(createInfo.oldSwapchain);
VkResult ret = ObjDisp(device)->CreateSwapchainKHR(Unwrap(device), &createInfo, pAllocator, pSwapChain);
if(ret == VK_SUCCESS)
{
ResourceId id = GetResourceManager()->WrapResource(Unwrap(device), *pSwapChain);
if(m_State >= WRITING)
{
Chunk *chunk = NULL;
{
CACHE_THREAD_SERIALISER();
SCOPED_SERIALISE_CONTEXT(CREATE_SWAP_BUFFER);
Serialise_vkCreateSwapchainKHR(localSerialiser, device, pCreateInfo, NULL, pSwapChain);
chunk = scope.Get();
}
VkResourceRecord *record = GetResourceManager()->AddResourceRecord(*pSwapChain);
record->AddChunk(chunk);
record->swapInfo = new SwapchainInfo();
SwapchainInfo &swapInfo = *record->swapInfo;
// sneaky casting of window handle into record
swapInfo.wndHandle = (RENDERDOC_WindowHandle)GetRecord(pCreateInfo->surface);
{
SCOPED_LOCK(m_SwapLookupLock);
m_SwapLookup[swapInfo.wndHandle] = *pSwapChain;
}
RenderDoc::Inst().AddFrameCapturer(LayerDisp(m_Instance), swapInfo.wndHandle, this);
swapInfo.format = pCreateInfo->imageFormat;
swapInfo.extent = pCreateInfo->imageExtent;
swapInfo.arraySize = pCreateInfo->imageArrayLayers;
VkResult vkr = VK_SUCCESS;
const VkLayerDispatchTable *vt = ObjDisp(device);
{
VkAttachmentDescription attDesc = {
0, pCreateInfo->imageFormat, VK_SAMPLE_COUNT_1_BIT,
VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_STORE_OP_STORE,
VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
};
VkAttachmentReference attRef = { 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL };
VkSubpassDescription sub = {
0, VK_PIPELINE_BIND_POINT_GRAPHICS,
0, NULL, // inputs
1, &attRef, // color
NULL, // resolve
NULL, // depth-stencil
0, NULL, // preserve
};
VkRenderPassCreateInfo rpinfo = {
VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, NULL, 0,
1, &attDesc,
1, &sub,
0, NULL, // dependencies
};
vkr = vt->CreateRenderPass(Unwrap(device), &rpinfo, NULL, &swapInfo.rp);
RDCASSERTEQUAL(vkr, VK_SUCCESS);
GetResourceManager()->WrapResource(Unwrap(device), swapInfo.rp);
}
// serialise out the swap chain images
{
uint32_t numSwapImages;
VkResult ret = vt->GetSwapchainImagesKHR(Unwrap(device), Unwrap(*pSwapChain), &numSwapImages, NULL);
RDCASSERTEQUAL(ret, VK_SUCCESS);
swapInfo.lastPresent = 0;
swapInfo.images.resize(numSwapImages);
for(uint32_t i=0; i < numSwapImages; i++)
{
swapInfo.images[i].im = VK_NULL_HANDLE;
swapInfo.images[i].view = VK_NULL_HANDLE;
swapInfo.images[i].fb = VK_NULL_HANDLE;
}
VkImage* images = new VkImage[numSwapImages];
// go through our own function so we assign these images IDs
ret = vkGetSwapchainImagesKHR(device, *pSwapChain, &numSwapImages, images);
RDCASSERTEQUAL(ret, VK_SUCCESS);
for(uint32_t i=0; i < numSwapImages; i++)
{
SwapchainInfo::SwapImage &swapImInfo = swapInfo.images[i];
// memory doesn't exist for genuine WSI created images
swapImInfo.im = images[i];
ResourceId imid = GetResID(images[i]);
VkImageSubresourceRange range;
range.baseMipLevel = range.baseArrayLayer = 0;
range.levelCount = 1;
range.layerCount = pCreateInfo->imageArrayLayers;
range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
// fill out image info so we track resource state barriers
{
SCOPED_LOCK(m_ImageLayoutsLock);
m_ImageLayouts[imid].subresourceStates.clear();
m_ImageLayouts[imid].subresourceStates.push_back(ImageRegionState(range, UNKNOWN_PREV_IMG_LAYOUT, VK_IMAGE_LAYOUT_UNDEFINED));
}
{
VkImageViewCreateInfo info = {
VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, NULL, 0,
Unwrap(images[i]), VK_IMAGE_VIEW_TYPE_2D,
pCreateInfo->imageFormat,
{ VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY },
{ VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 },
};
vkr = vt->CreateImageView(Unwrap(device), &info, NULL, &swapImInfo.view);
RDCASSERTEQUAL(vkr, VK_SUCCESS);
GetResourceManager()->WrapResource(Unwrap(device), swapImInfo.view);
VkFramebufferCreateInfo fbinfo = {
VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, NULL, 0,
Unwrap(swapInfo.rp),
1, UnwrapPtr(swapImInfo.view),
(uint32_t)pCreateInfo->imageExtent.width, (uint32_t)pCreateInfo->imageExtent.height, 1,
};
vkr = vt->CreateFramebuffer(Unwrap(device), &fbinfo, NULL, &swapImInfo.fb);
RDCASSERTEQUAL(vkr, VK_SUCCESS);
GetResourceManager()->WrapResource(Unwrap(device), swapImInfo.fb);
}
}
SAFE_DELETE_ARRAY(images);
}
}
else
{
GetResourceManager()->AddLiveResource(id, *pSwapChain);
}
}
return ret;
}
void createSwapChainAndImages(VulkanContext& context, VulkanSurfaceContext& surfaceContext) {
// Pick an image count and format. According to section 30.5 of VK 1.1, maxImageCount of zero
// apparently means "that there is no limit on the number of images, though there may be limits
// related to the total amount of memory used by presentable images."
uint32_t desiredImageCount = 2;
const uint32_t maxImageCount = surfaceContext.surfaceCapabilities.maxImageCount;
if (desiredImageCount < surfaceContext.surfaceCapabilities.minImageCount ||
(maxImageCount != 0 && desiredImageCount > maxImageCount)) {
utils::slog.e << "Swap chain does not support " << desiredImageCount << " images.\n";
desiredImageCount = surfaceContext.surfaceCapabilities.minImageCount;
}
surfaceContext.surfaceFormat = surfaceContext.surfaceFormats[0];
for (const VkSurfaceFormatKHR& format : surfaceContext.surfaceFormats) {
if (format.format == VK_FORMAT_R8G8B8A8_UNORM) {
surfaceContext.surfaceFormat = format;
break;
}
}
const auto compositionCaps = surfaceContext.surfaceCapabilities.supportedCompositeAlpha;
const auto compositeAlpha = (compositionCaps & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR) ?
VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR : VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
// Create the low-level swap chain.
const auto size = surfaceContext.surfaceCapabilities.currentExtent;
VkSwapchainCreateInfoKHR createInfo {
.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
.surface = surfaceContext.surface,
.minImageCount = desiredImageCount,
.imageFormat = surfaceContext.surfaceFormat.format,
.imageColorSpace = surfaceContext.surfaceFormat.colorSpace,
.imageExtent = size,
.imageArrayLayers = 1,
.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR,
.compositeAlpha = compositeAlpha,
.presentMode = VK_PRESENT_MODE_FIFO_KHR,
.clipped = VK_TRUE
};
VkSwapchainKHR swapchain;
VkResult result = vkCreateSwapchainKHR(context.device, &createInfo, VKALLOC, &swapchain);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkGetPhysicalDeviceSurfaceFormatsKHR error.");
surfaceContext.swapchain = swapchain;
// Extract the VkImage handles from the swap chain.
uint32_t imageCount;
result = vkGetSwapchainImagesKHR(context.device, swapchain, &imageCount, nullptr);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkGetSwapchainImagesKHR count error.");
surfaceContext.swapContexts.resize(imageCount);
std::vector<VkImage> images(imageCount);
result = vkGetSwapchainImagesKHR(context.device, swapchain, &imageCount,
images.data());
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkGetSwapchainImagesKHR error.");
for (size_t i = 0; i < images.size(); ++i) {
surfaceContext.swapContexts[i].attachment = {
.image = images[i],
.format = surfaceContext.surfaceFormat.format
};
}
utils::slog.i
<< "vkCreateSwapchain"
<< ": " << size.width << "x" << size.height
<< ", " << surfaceContext.surfaceFormat.format
<< ", " << surfaceContext.surfaceFormat.colorSpace
<< ", " << imageCount
<< utils::io::endl;
// Create image views.
VkImageViewCreateInfo ivCreateInfo = {};
ivCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
ivCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
ivCreateInfo.format = surfaceContext.surfaceFormat.format;
ivCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
ivCreateInfo.subresourceRange.levelCount = 1;
ivCreateInfo.subresourceRange.layerCount = 1;
for (size_t i = 0; i < images.size(); ++i) {
ivCreateInfo.image = images[i];
result = vkCreateImageView(context.device, &ivCreateInfo, VKALLOC,
&surfaceContext.swapContexts[i].attachment.view);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkCreateImageView error.");
}
createSemaphore(context.device, &surfaceContext.imageAvailable);
createSemaphore(context.device, &surfaceContext.renderingFinished);
surfaceContext.depth = {};
}
void createDepthBuffer(VulkanContext& context, VulkanSurfaceContext& surfaceContext,
VkFormat depthFormat) {
assert(context.cmdbuffer);
// Create an appropriately-sized device-only VkImage.
const auto size = surfaceContext.surfaceCapabilities.currentExtent;
VkImage depthImage;
VkImageCreateInfo imageInfo {
.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
.imageType = VK_IMAGE_TYPE_2D,
.extent = { size.width, size.height, 1 },
.format = depthFormat,
.mipLevels = 1,
.arrayLayers = 1,
.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
.samples = VK_SAMPLE_COUNT_1_BIT,
};
VkResult error = vkCreateImage(context.device, &imageInfo, VKALLOC, &depthImage);
ASSERT_POSTCONDITION(!error, "Unable to create depth image.");
// Allocate memory for the VkImage and bind it.
VkMemoryRequirements memReqs;
vkGetImageMemoryRequirements(context.device, depthImage, &memReqs);
VkMemoryAllocateInfo allocInfo {
.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
.allocationSize = memReqs.size,
.memoryTypeIndex = selectMemoryType(context, memReqs.memoryTypeBits,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
};
error = vkAllocateMemory(context.device, &allocInfo, nullptr,
&surfaceContext.depth.memory);
ASSERT_POSTCONDITION(!error, "Unable to allocate depth memory.");
error = vkBindImageMemory(context.device, depthImage, surfaceContext.depth.memory, 0);
ASSERT_POSTCONDITION(!error, "Unable to bind depth memory.");
// Create a VkImageView so that we can attach depth to the framebuffer.
VkImageView depthView;
VkImageViewCreateInfo viewInfo {
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.image = depthImage,
.viewType = VK_IMAGE_VIEW_TYPE_2D,
.format = depthFormat,
.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT,
.subresourceRange.levelCount = 1,
.subresourceRange.layerCount = 1,
};
error = vkCreateImageView(context.device, &viewInfo, VKALLOC, &depthView);
ASSERT_POSTCONDITION(!error, "Unable to create depth view.");
// Transition the depth image into an optimal layout.
VkImageMemoryBarrier barrier {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = depthImage,
.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT,
.subresourceRange.levelCount = 1,
.subresourceRange.layerCount = 1,
.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT
};
vkCmdPipelineBarrier(context.cmdbuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
// Go ahead and set the depth attachment fields, which serves as a signal to VulkanDriver that
// it is now ready.
surfaceContext.depth.view = depthView;
surfaceContext.depth.image = depthImage;
surfaceContext.depth.format = depthFormat;
}
void transitionDepthBuffer(VulkanContext& context, VulkanSurfaceContext& sc, VkFormat depthFormat) {
// Begin a new command buffer solely for the purpose of transitioning the image layout.
SwapContext& swap = getSwapContext(context);
VkResult result = vkWaitForFences(context.device, 1, &swap.fence, VK_FALSE, UINT64_MAX);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkWaitForFences error.");
result = vkResetFences(context.device, 1, &swap.fence);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkResetFences error.");
VkCommandBuffer cmdbuffer = swap.cmdbuffer;
result = vkResetCommandBuffer(cmdbuffer, 0);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkResetCommandBuffer error.");
VkCommandBufferBeginInfo beginInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
};
result = vkBeginCommandBuffer(cmdbuffer, &beginInfo);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkBeginCommandBuffer error.");
context.cmdbuffer = cmdbuffer;
// Create the depth buffer and issue a pipeline barrier command.
createDepthBuffer(context, sc, depthFormat);
// Flush the command buffer.
result = vkEndCommandBuffer(context.cmdbuffer);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkEndCommandBuffer error.");
context.cmdbuffer = nullptr;
VkSubmitInfo submitInfo {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.commandBufferCount = 1,
.pCommandBuffers = &swap.cmdbuffer,
};
result = vkQueueSubmit(context.graphicsQueue, 1, &submitInfo, swap.fence);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkQueueSubmit error.");
swap.submitted = false;
}
void createCommandBuffersAndFences(VulkanContext& context, VulkanSurfaceContext& surfaceContext) {
// Allocate command buffers.
VkCommandBufferAllocateInfo allocateInfo = {};
allocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocateInfo.commandPool = context.commandPool;
allocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocateInfo.commandBufferCount = (uint32_t) surfaceContext.swapContexts.size();
std::vector<VkCommandBuffer> cmdbufs(allocateInfo.commandBufferCount);
VkResult result = vkAllocateCommandBuffers(context.device, &allocateInfo, cmdbufs.data());
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkAllocateCommandBuffers error.");
for (uint32_t i = 0; i < allocateInfo.commandBufferCount; ++i) {
surfaceContext.swapContexts[i].cmdbuffer = cmdbufs[i];
}
// Create fences.
VkFenceCreateInfo fenceCreateInfo = {};
fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceCreateInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
for (uint32_t i = 0; i < allocateInfo.commandBufferCount; i++) {
result = vkCreateFence(context.device, &fenceCreateInfo, VKALLOC,
&surfaceContext.swapContexts[i].fence);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkCreateFence error.");
}
}
void destroySurfaceContext(VulkanContext& context, VulkanSurfaceContext& surfaceContext) {
for (SwapContext& swapContext : surfaceContext.swapContexts) {
vkFreeCommandBuffers(context.device, context.commandPool, 1, &swapContext.cmdbuffer);
vkDestroyFence(context.device, swapContext.fence, VKALLOC);
vkDestroyImageView(context.device, swapContext.attachment.view, VKALLOC);
swapContext.fence = VK_NULL_HANDLE;
swapContext.attachment.view = VK_NULL_HANDLE;
}
vkDestroySwapchainKHR(context.device, surfaceContext.swapchain, VKALLOC);
vkDestroySemaphore(context.device, surfaceContext.imageAvailable, VKALLOC);
vkDestroySemaphore(context.device, surfaceContext.renderingFinished, VKALLOC);
vkDestroySurfaceKHR(context.instance, surfaceContext.surface, VKALLOC);
vkDestroyImageView(context.device, surfaceContext.depth.view, VKALLOC);
vkDestroyImage(context.device, surfaceContext.depth.image, VKALLOC);
vkFreeMemory(context.device, surfaceContext.depth.memory, VKALLOC);
if (context.currentSurface == &surfaceContext) {
context.currentSurface = nullptr;
}
}
uint32_t selectMemoryType(VulkanContext& context, uint32_t flags, VkFlags reqs) {
for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) {
if (flags & 1) {
if ((context.memoryProperties.memoryTypes[i].propertyFlags & reqs) == reqs) {
return i;
}
}
flags >>= 1;
}
ASSERT_POSTCONDITION(false, "Unable to find a memory type that meets requirements.");
return (uint32_t) ~0ul;
}
VkFormat getVkFormat(ElementType type, bool normalized) {
using ElementType = ElementType;
if (normalized) {
switch (type) {
// Single Component Types
case ElementType::BYTE: return VK_FORMAT_R8_SNORM;
case ElementType::UBYTE: return VK_FORMAT_R8_UNORM;
case ElementType::SHORT: return VK_FORMAT_R16_SNORM;
case ElementType::USHORT: return VK_FORMAT_R16_UNORM;
// Two Component Types
case ElementType::BYTE2: return VK_FORMAT_R8G8_SNORM;
case ElementType::UBYTE2: return VK_FORMAT_R8G8_UNORM;
case ElementType::SHORT2: return VK_FORMAT_R16G16_SNORM;
case ElementType::USHORT2: return VK_FORMAT_R16G16_UNORM;
// Three Component Types
case ElementType::BYTE3: return VK_FORMAT_R8G8B8_SNORM;
case ElementType::UBYTE3: return VK_FORMAT_R8G8B8_UNORM;
case ElementType::SHORT3: return VK_FORMAT_R16G16B16_SNORM;
case ElementType::USHORT3: return VK_FORMAT_R16G16B16_UNORM;
// Four Component Types
case ElementType::BYTE4: return VK_FORMAT_R8G8B8A8_SNORM;
case ElementType::UBYTE4: return VK_FORMAT_R8G8B8A8_UNORM;
case ElementType::SHORT4: return VK_FORMAT_R16G16B16A16_SNORM;
case ElementType::USHORT4: return VK_FORMAT_R16G16B16A16_UNORM;
default:
ASSERT_POSTCONDITION(false, "Normalized format does not exist.");
return VK_FORMAT_UNDEFINED;
}
}
switch (type) {
// Single Component Types
case ElementType::BYTE: return VK_FORMAT_R8_SINT;
case ElementType::UBYTE: return VK_FORMAT_R8_UINT;
case ElementType::SHORT: return VK_FORMAT_R16_SINT;
case ElementType::USHORT: return VK_FORMAT_R16_UINT;
case ElementType::HALF: return VK_FORMAT_R16_SFLOAT;
case ElementType::INT: return VK_FORMAT_R32_SINT;
case ElementType::UINT: return VK_FORMAT_R32_UINT;
case ElementType::FLOAT: return VK_FORMAT_R32_SFLOAT;
// Two Component Types
case ElementType::BYTE2: return VK_FORMAT_R8G8_SINT;
case ElementType::UBYTE2: return VK_FORMAT_R8G8_UINT;
case ElementType::SHORT2: return VK_FORMAT_R16G16_SINT;
case ElementType::USHORT2: return VK_FORMAT_R16G16_UINT;
case ElementType::HALF2: return VK_FORMAT_R16G16_SFLOAT;
case ElementType::FLOAT2: return VK_FORMAT_R32G32_SFLOAT;
// Three Component Types
case ElementType::BYTE3: return VK_FORMAT_R8G8B8_SINT;
case ElementType::UBYTE3: return VK_FORMAT_R8G8B8_UINT;
case ElementType::SHORT3: return VK_FORMAT_R16G16B16_SINT;
case ElementType::USHORT3: return VK_FORMAT_R16G16B16_UINT;
case ElementType::HALF3: return VK_FORMAT_R16G16B16_SFLOAT;
case ElementType::FLOAT3: return VK_FORMAT_R32G32B32_SFLOAT;
// Four Component Types
case ElementType::BYTE4: return VK_FORMAT_R8G8B8A8_SINT;
case ElementType::UBYTE4: return VK_FORMAT_R8G8B8A8_UINT;
case ElementType::SHORT4: return VK_FORMAT_R16G16B16A16_SINT;
case ElementType::USHORT4: return VK_FORMAT_R16G16B16A16_UINT;
case ElementType::HALF4: return VK_FORMAT_R16G16B16A16_SFLOAT;
case ElementType::FLOAT4: return VK_FORMAT_R32G32B32A32_SFLOAT;
}
return VK_FORMAT_UNDEFINED;
}
VkFormat getVkFormat(TextureFormat format) {
using TextureFormat = TextureFormat;
switch (format) {
// 8 bits per element.
case TextureFormat::R8: return VK_FORMAT_R8_UNORM;
case TextureFormat::R8_SNORM: return VK_FORMAT_R8_SNORM;
case TextureFormat::R8UI: return VK_FORMAT_R8_UINT;
case TextureFormat::R8I: return VK_FORMAT_R8_SINT;
case TextureFormat::STENCIL8: return VK_FORMAT_S8_UINT;
// 16 bits per element.
case TextureFormat::R16F: return VK_FORMAT_R16_SFLOAT;
case TextureFormat::R16UI: return VK_FORMAT_R16_UINT;
case TextureFormat::R16I: return VK_FORMAT_R16_SINT;
case TextureFormat::RG8: return VK_FORMAT_R8G8_UNORM;
case TextureFormat::RG8_SNORM: return VK_FORMAT_R8G8_SNORM;
case TextureFormat::RG8UI: return VK_FORMAT_R8G8_UINT;
case TextureFormat::RG8I: return VK_FORMAT_R8G8_SINT;
case TextureFormat::RGB565: return VK_FORMAT_R5G6B5_UNORM_PACK16;
case TextureFormat::RGB5_A1: return VK_FORMAT_R5G5B5A1_UNORM_PACK16;
case TextureFormat::RGBA4: return VK_FORMAT_R4G4B4A4_UNORM_PACK16;
case TextureFormat::DEPTH16: return VK_FORMAT_D16_UNORM;
// 24 bits per element. In practice, very few GPU vendors support these. For simplicity
// we just assume they are not supported, not bothering to query the device capabilities.
// Note that VK_FORMAT_ enums for 24-bit formats exist, but are meant for vertex attributes.
case TextureFormat::RGB8:
case TextureFormat::SRGB8:
case TextureFormat::RGB8_SNORM:
case TextureFormat::RGB8UI:
case TextureFormat::RGB8I:
case TextureFormat::DEPTH24:
return VK_FORMAT_UNDEFINED;
// 32 bits per element.
case TextureFormat::R32F: return VK_FORMAT_R32_SFLOAT;
case TextureFormat::R32UI: return VK_FORMAT_R32_UINT;
case TextureFormat::R32I: return VK_FORMAT_R32_SINT;
case TextureFormat::RG16F: return VK_FORMAT_R16G16_SFLOAT;
case TextureFormat::RG16UI: return VK_FORMAT_R16G16_UINT;
case TextureFormat::RG16I: return VK_FORMAT_R16G16_SINT;
case TextureFormat::R11F_G11F_B10F: return VK_FORMAT_B10G11R11_UFLOAT_PACK32;
case TextureFormat::RGB9_E5: return VK_FORMAT_E5B9G9R9_UFLOAT_PACK32;
case TextureFormat::RGBA8: return VK_FORMAT_R8G8B8A8_UNORM;
case TextureFormat::SRGB8_A8: return VK_FORMAT_R8G8B8A8_SRGB;
case TextureFormat::RGBA8_SNORM: return VK_FORMAT_R8G8B8A8_SNORM;
case TextureFormat::RGBM: return VK_FORMAT_R8G8B8A8_UNORM;
case TextureFormat::RGB10_A2: return VK_FORMAT_A2R10G10B10_UNORM_PACK32;
case TextureFormat::RGBA8UI: return VK_FORMAT_R8G8B8A8_UINT;
case TextureFormat::RGBA8I: return VK_FORMAT_R8G8B8A8_SINT;
case TextureFormat::DEPTH32F: return VK_FORMAT_D32_SFLOAT;
case TextureFormat::DEPTH24_STENCIL8: return VK_FORMAT_D24_UNORM_S8_UINT;
case TextureFormat::DEPTH32F_STENCIL8: return VK_FORMAT_D32_SFLOAT_S8_UINT;
// 48 bits per element. Note that many GPU vendors do not support these.
case TextureFormat::RGB16F: return VK_FORMAT_R16G16B16_SFLOAT;
case TextureFormat::RGB16UI: return VK_FORMAT_R16G16B16_UINT;
case TextureFormat::RGB16I: return VK_FORMAT_R16G16B16_SINT;
// 64 bits per element.
case TextureFormat::RG32F: return VK_FORMAT_R32G32_SFLOAT;
case TextureFormat::RG32UI: return VK_FORMAT_R32G32_UINT;
case TextureFormat::RG32I: return VK_FORMAT_R32G32_SINT;
case TextureFormat::RGBA16F: return VK_FORMAT_R16G16B16A16_SFLOAT;
case TextureFormat::RGBA16UI: return VK_FORMAT_R16G16B16A16_UINT;
case TextureFormat::RGBA16I: return VK_FORMAT_R16G16B16A16_SINT;
// 96-bits per element.
case TextureFormat::RGB32F: return VK_FORMAT_R32G32B32_SFLOAT;
case TextureFormat::RGB32UI: return VK_FORMAT_R32G32B32_UINT;
case TextureFormat::RGB32I: return VK_FORMAT_R32G32B32_SINT;
// 128-bits per element
case TextureFormat::RGBA32F: return VK_FORMAT_R32G32B32A32_SFLOAT;
case TextureFormat::RGBA32UI: return VK_FORMAT_R32G32B32A32_UINT;
case TextureFormat::RGBA32I: return VK_FORMAT_R32G32B32A32_SINT;
default:
return VK_FORMAT_UNDEFINED;
}
}
uint32_t getBytesPerPixel(TextureFormat format) {
return details::FTexture::getFormatSize(format);
}
// See also FTexture::computeTextureDataSize, which takes a public-facing Texture format rather
// than a driver-level Texture format, and can account for a specified byte alignment.
uint32_t computeSize(TextureFormat format, uint32_t w, uint32_t h, uint32_t d) {
const size_t bytesPerTexel = details::FTexture::getFormatSize(format);
return bytesPerTexel * w * h * d;
}
SwapContext& getSwapContext(VulkanContext& context) {
VulkanSurfaceContext& surface = *context.currentSurface;
return surface.swapContexts[surface.currentSwapIndex];
}
bool hasPendingWork(VulkanContext& context) {
if (context.pendingWork.size() > 0) {
return true;
}
if (context.currentSurface) {
for (auto& swapContext : context.currentSurface->swapContexts) {
if (swapContext.pendingWork.size() > 0) {
return true;
}
}
}
return false;
}
VkCompareOp getCompareOp(SamplerCompareFunc func) {
using Compare = driver::SamplerCompareFunc;
switch (func) {
case Compare::LE: return VK_COMPARE_OP_LESS_OR_EQUAL;
case Compare::GE: return VK_COMPARE_OP_GREATER_OR_EQUAL;
case Compare::L: return VK_COMPARE_OP_LESS;
case Compare::G: return VK_COMPARE_OP_GREATER;
case Compare::E: return VK_COMPARE_OP_EQUAL;
case Compare::NE: return VK_COMPARE_OP_NOT_EQUAL;
case Compare::A: return VK_COMPARE_OP_ALWAYS;
case Compare::N: return VK_COMPARE_OP_NEVER;
}
}
VkBlendFactor getBlendFactor(BlendFunction mode) {
using BlendFunction = filament::driver::BlendFunction;
switch (mode) {
case BlendFunction::ZERO: return VK_BLEND_FACTOR_ZERO;
case BlendFunction::ONE: return VK_BLEND_FACTOR_ONE;
case BlendFunction::SRC_COLOR: return VK_BLEND_FACTOR_SRC_COLOR;
case BlendFunction::ONE_MINUS_SRC_COLOR: return VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
case BlendFunction::DST_COLOR: return VK_BLEND_FACTOR_DST_COLOR;
case BlendFunction::ONE_MINUS_DST_COLOR: return VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
case BlendFunction::SRC_ALPHA: return VK_BLEND_FACTOR_SRC_ALPHA;
case BlendFunction::ONE_MINUS_SRC_ALPHA: return VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
case BlendFunction::DST_ALPHA: return VK_BLEND_FACTOR_DST_ALPHA;
case BlendFunction::ONE_MINUS_DST_ALPHA: return VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
case BlendFunction::SRC_ALPHA_SATURATE: return VK_BLEND_FACTOR_SRC_ALPHA_SATURATE;
}
}
void waitForIdle(VulkanContext& context) {
// If there's no valid GPU then we have nothing to do.
if (!context.device) {
return;
}
// If there's no surface, then there's no command buffer.
if (!context.currentSurface) {
return;
}
// First, wait for submitted command buffer(s) to finish.
VkFence fences[2];
uint32_t nfences = 0;
auto& surfaceContext = *context.currentSurface;
for (auto& swapContext : surfaceContext.swapContexts) {
assert(nfences < 2);
if (swapContext.submitted && swapContext.fence) {
fences[nfences++] = swapContext.fence;
swapContext.submitted = false;
}
}
if (nfences > 0) {
vkWaitForFences(context.device, nfences, fences, VK_FALSE, ~0ull);
}
// If we don't have any pending work, we're done.
if (!hasPendingWork(context)) {
return;
}
// We cannot invoke arbitrary commands inside a render pass.
assert(context.currentRenderPass.renderPass == VK_NULL_HANDLE);
// Create a one-off command buffer to avoid the cost of swap chain acquisition and to avoid
// the possibility of SURFACE_LOST. Note that Vulkan command buffers use the Allocate/Free
// model instead of Create/Destroy and are therefore okay to create at a high frequency.
VkCommandBuffer cmdbuffer;
VkFence fence;
VkCommandBufferBeginInfo beginInfo { .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
VkCommandBufferAllocateInfo allocateInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
.commandPool = context.commandPool,
.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
.commandBufferCount = 1
};
VkFenceCreateInfo fenceCreateInfo { .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, };
vkAllocateCommandBuffers(context.device, &allocateInfo, &cmdbuffer);
vkCreateFence(context.device, &fenceCreateInfo, VKALLOC, &fence);
// Keep performing work until there's nothing queued up. This should never iterate more than
// a couple times because the only work we queue up is for resource transition / reclamation.
VkPipelineStageFlags waitDestStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
VkSubmitInfo submitInfo {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.pWaitDstStageMask = &waitDestStageMask,
.commandBufferCount = 1,
.pCommandBuffers = &cmdbuffer,
};
int cycles = 0;
while (hasPendingWork(context)) {
if (cycles++ > 2) {
utils::slog.e << "Unexpected daisychaining of pending work." << utils::io::endl;
break;
}
for (auto& swapContext : context.currentSurface->swapContexts) {
vkBeginCommandBuffer(cmdbuffer, &beginInfo);
performPendingWork(context, swapContext, cmdbuffer);
vkEndCommandBuffer(cmdbuffer);
vkQueueSubmit(context.graphicsQueue, 1, &submitInfo, fence);
vkWaitForFences(context.device, 1, &fence, VK_FALSE, UINT64_MAX);
vkResetFences(context.device, 1, &fence);
vkResetCommandBuffer(cmdbuffer, 0);
}
}
vkFreeCommandBuffers(context.device, context.commandPool, 1, &cmdbuffer);
vkDestroyFence(context.device, fence, VKALLOC);
}
void acquireCommandBuffer(VulkanContext& context) {
// Ask Vulkan for the next image in the swap chain and update the currentSwapIndex.
VulkanSurfaceContext& surface = *context.currentSurface;
VkResult result = vkAcquireNextImageKHR(context.device, surface.swapchain,
UINT64_MAX, surface.imageAvailable, VK_NULL_HANDLE, &surface.currentSwapIndex);
ASSERT_POSTCONDITION(result != VK_ERROR_OUT_OF_DATE_KHR,
"Stale / resized swap chain not yet supported.");
ASSERT_POSTCONDITION(result == VK_SUBOPTIMAL_KHR || result == VK_SUCCESS,
"vkAcquireNextImageKHR error.");
SwapContext& swap = getSwapContext(context);
// Ensure that the previous submission of this command buffer has finished.
result = vkWaitForFences(context.device, 1, &swap.fence, VK_FALSE, UINT64_MAX);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkWaitForFences error.");
// Restart the command buffer.
result = vkResetFences(context.device, 1, &swap.fence);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkResetFences error.");
VkCommandBuffer cmdbuffer = swap.cmdbuffer;
VkResult error = vkResetCommandBuffer(cmdbuffer, 0);
ASSERT_POSTCONDITION(not error, "vkResetCommandBuffer error.");
VkCommandBufferBeginInfo beginInfo {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
};
error = vkBeginCommandBuffer(cmdbuffer, &beginInfo);
ASSERT_POSTCONDITION(not error, "vkBeginCommandBuffer error.");
context.cmdbuffer = cmdbuffer;
swap.submitted = false;
}
void releaseCommandBuffer(VulkanContext& context) {
// Finalize the command buffer and set the cmdbuffer pointer to null.
VkResult result = vkEndCommandBuffer(context.cmdbuffer);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkEndCommandBuffer error.");
context.cmdbuffer = nullptr;
// Submit the command buffer.
VkPipelineStageFlags waitDestStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
VulkanSurfaceContext& surfaceContext = *context.currentSurface;
SwapContext& swapContext = getSwapContext(context);
VkSubmitInfo submitInfo {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.waitSemaphoreCount = 1u,
.pWaitSemaphores = &surfaceContext.imageAvailable,
.pWaitDstStageMask = &waitDestStageMask,
.commandBufferCount = 1,
.pCommandBuffers = &swapContext.cmdbuffer,
.signalSemaphoreCount = 1u,
.pSignalSemaphores = &surfaceContext.renderingFinished,
};
result = vkQueueSubmit(context.graphicsQueue, 1, &submitInfo, swapContext.fence);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkQueueSubmit error.");
swapContext.submitted = true;
}
void performPendingWork(VulkanContext& context, SwapContext& swapContext, VkCommandBuffer cmdbuf) {
// First, execute pending tasks that are specific to this swap context. Copy the tasks into a
// local queue first, which allows newly added tasks to be deferred until the next frame.
decltype(swapContext.pendingWork) tasks;
tasks.swap(swapContext.pendingWork);
for (auto& callback : tasks) {
callback(cmdbuf);
}
// Next, execute the global pending work. Again, we copy the work queue into a local queue
// to allow tasks to re-add themselves.
tasks.clear();
tasks.swap(context.pendingWork);
for (auto& callback : tasks) {
callback(cmdbuf);
}
}
// Flushes the command buffer and waits for it to finish executing. Useful for diagnosing
// sychronization issues.
void flushCommandBuffer(VulkanContext& context) {
VulkanSurfaceContext& surface = *context.currentSurface;
const SwapContext& sc = surface.swapContexts[surface.currentSwapIndex];
// Submit the command buffer.
VkResult error = vkEndCommandBuffer(context.cmdbuffer);
ASSERT_POSTCONDITION(!error, "vkEndCommandBuffer error.");
VkPipelineStageFlags waitDestStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
VkSubmitInfo submitInfo {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.pWaitDstStageMask = &waitDestStageMask,
.commandBufferCount = 1,
.pCommandBuffers = &context.cmdbuffer,
};
error = vkQueueSubmit(context.graphicsQueue, 1, &submitInfo, sc.fence);
ASSERT_POSTCONDITION(!error, "vkQueueSubmit error.");
// Restart the command buffer.
error = vkWaitForFences(context.device, 1, &sc.fence, VK_FALSE, UINT64_MAX);
ASSERT_POSTCONDITION(!error, "vkWaitForFences error.");
error = vkResetFences(context.device, 1, &sc.fence);
ASSERT_POSTCONDITION(!error, "vkResetFences error.");
error = vkResetCommandBuffer(context.cmdbuffer, 0);
ASSERT_POSTCONDITION(!error, "vkResetCommandBuffer error.");
VkCommandBufferBeginInfo beginInfo {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
};
error = vkBeginCommandBuffer(context.cmdbuffer, &beginInfo);
ASSERT_POSTCONDITION(!error, "vkBeginCommandBuffer error.");
}
VkFormat findSupportedFormat(VulkanContext& context, const std::vector<VkFormat>& candidates,
VkImageTiling tiling, VkFormatFeatureFlags features) {
for (VkFormat format : candidates) {
VkFormatProperties props;
vkGetPhysicalDeviceFormatProperties(context.physicalDevice, format, &props);
if (tiling == VK_IMAGE_TILING_LINEAR &&
(props.linearTilingFeatures & features) == features) {
return format;
} else if (tiling == VK_IMAGE_TILING_OPTIMAL &&
(props.optimalTilingFeatures & features) == features) {
return format;
}
}
return VK_FORMAT_UNDEFINED;
}
} // namespace filament
} // namespace driver
bool VulkanCommon::CreateSwapChain() {
if( Vulkan.Device != VK_NULL_HANDLE ) {
vkDeviceWaitIdle( Vulkan.Device );
}
for( size_t i = 0; i < Vulkan.SwapChain.Images.size(); ++i ) {
if( Vulkan.SwapChain.Images[i].ImageView != VK_NULL_HANDLE ) {
vkDestroyImageView( GetDevice(), Vulkan.SwapChain.Images[i].ImageView, nullptr );
Vulkan.SwapChain.Images[i].ImageView = VK_NULL_HANDLE;
}
}
Vulkan.SwapChain.Images.clear();
VkSurfaceCapabilitiesKHR surface_capabilities;
if( vkGetPhysicalDeviceSurfaceCapabilitiesKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &surface_capabilities ) != VK_SUCCESS ) {
std::cout << "Could not check presentation surface capabilities!" << std::endl;
return false;
}
uint32_t formats_count;
if( (vkGetPhysicalDeviceSurfaceFormatsKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &formats_count, nullptr ) != VK_SUCCESS) ||
(formats_count == 0) ) {
std::cout << "Error occurred during presentation surface formats enumeration!" << std::endl;
return false;
}
std::vector<VkSurfaceFormatKHR> surface_formats( formats_count );
if( vkGetPhysicalDeviceSurfaceFormatsKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &formats_count, &surface_formats[0] ) != VK_SUCCESS ) {
std::cout << "Error occurred during presentation surface formats enumeration!" << std::endl;
return false;
}
uint32_t present_modes_count;
if( (vkGetPhysicalDeviceSurfacePresentModesKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &present_modes_count, nullptr ) != VK_SUCCESS) ||
(present_modes_count == 0) ) {
std::cout << "Error occurred during presentation surface present modes enumeration!" << std::endl;
return false;
}
std::vector<VkPresentModeKHR> present_modes( present_modes_count );
if( vkGetPhysicalDeviceSurfacePresentModesKHR( Vulkan.PhysicalDevice, Vulkan.PresentationSurface, &present_modes_count, &present_modes[0] ) != VK_SUCCESS ) {
std::cout << "Error occurred during presentation surface present modes enumeration!" << std::endl;
return false;
}
uint32_t desired_number_of_images = GetSwapChainNumImages( surface_capabilities );
VkSurfaceFormatKHR desired_format = GetSwapChainFormat( surface_formats );
VkExtent2D desired_extent = GetSwapChainExtent( surface_capabilities );
VkImageUsageFlags desired_usage = GetSwapChainUsageFlags( surface_capabilities );
VkSurfaceTransformFlagBitsKHR desired_transform = GetSwapChainTransform( surface_capabilities );
VkPresentModeKHR desired_present_mode = GetSwapChainPresentMode( present_modes );
VkSwapchainKHR old_swap_chain = Vulkan.SwapChain.Handle;
if( static_cast<int>(desired_usage) == -1 ) {
return false;
}
if( static_cast<int>(desired_present_mode) == -1 ) {
return false;
}
VkSwapchainCreateInfoKHR swap_chain_create_info = {
VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, // VkStructureType sType
nullptr, // const void *pNext
0, // VkSwapchainCreateFlagsKHR flags
Vulkan.PresentationSurface, // VkSurfaceKHR surface
desired_number_of_images, // uint32_t minImageCount
desired_format.format, // VkFormat imageFormat
desired_format.colorSpace, // VkColorSpaceKHR imageColorSpace
desired_extent, // VkExtent2D imageExtent
1, // uint32_t imageArrayLayers
desired_usage, // VkImageUsageFlags imageUsage
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode imageSharingMode
0, // uint32_t queueFamilyIndexCount
nullptr, // const uint32_t *pQueueFamilyIndices
desired_transform, // VkSurfaceTransformFlagBitsKHR preTransform
VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, // VkCompositeAlphaFlagBitsKHR compositeAlpha
desired_present_mode, // VkPresentModeKHR presentMode
VK_TRUE, // VkBool32 clipped
old_swap_chain // VkSwapchainKHR oldSwapchain
};
if( vkCreateSwapchainKHR( Vulkan.Device, &swap_chain_create_info, nullptr, &Vulkan.SwapChain.Handle ) != VK_SUCCESS ) {
std::cout << "Could not create swap chain!" << std::endl;
return false;
}
if( old_swap_chain != VK_NULL_HANDLE ) {
vkDestroySwapchainKHR( Vulkan.Device, old_swap_chain, nullptr );
}
Vulkan.SwapChain.Format = desired_format.format;
uint32_t image_count = 0;
if( (vkGetSwapchainImagesKHR( Vulkan.Device, Vulkan.SwapChain.Handle, &image_count, nullptr ) != VK_SUCCESS) ||
(image_count == 0) ) {
std::cout << "Could not get swap chain images!" << std::endl;
return false;
}
Vulkan.SwapChain.Images.resize( image_count );
std::vector<VkImage> images( image_count );
if( vkGetSwapchainImagesKHR( Vulkan.Device, Vulkan.SwapChain.Handle, &image_count, &images[0] ) != VK_SUCCESS ) {
std::cout << "Could not get swap chain images!" << std::endl;
return false;
}
for( size_t i = 0; i < Vulkan.SwapChain.Images.size(); ++i ) {
Vulkan.SwapChain.Images[i].Handle = images[i];
}
Vulkan.SwapChain.Extent = desired_extent;
return CreateSwapChainImageViews();
}
void VulkanRenderManager::CreateBackbuffers() {
VkResult res = vkGetSwapchainImagesKHR(vulkan_->GetDevice(), vulkan_->GetSwapchain(), &swapchainImageCount_, nullptr);
assert(res == VK_SUCCESS);
VkImage *swapchainImages = new VkImage[swapchainImageCount_];
res = vkGetSwapchainImagesKHR(vulkan_->GetDevice(), vulkan_->GetSwapchain(), &swapchainImageCount_, swapchainImages);
if (res != VK_SUCCESS) {
ELOG("vkGetSwapchainImagesKHR failed");
delete[] swapchainImages;
return;
}
VkCommandBuffer cmdInit = GetInitCmd();
for (uint32_t i = 0; i < swapchainImageCount_; i++) {
SwapchainImageData sc_buffer;
sc_buffer.image = swapchainImages[i];
VkImageViewCreateInfo color_image_view = { VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
color_image_view.format = vulkan_->GetSwapchainFormat();
color_image_view.components.r = VK_COMPONENT_SWIZZLE_R;
color_image_view.components.g = VK_COMPONENT_SWIZZLE_G;
color_image_view.components.b = VK_COMPONENT_SWIZZLE_B;
color_image_view.components.a = VK_COMPONENT_SWIZZLE_A;
color_image_view.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
color_image_view.subresourceRange.baseMipLevel = 0;
color_image_view.subresourceRange.levelCount = 1;
color_image_view.subresourceRange.baseArrayLayer = 0;
color_image_view.subresourceRange.layerCount = 1;
color_image_view.viewType = VK_IMAGE_VIEW_TYPE_2D;
color_image_view.flags = 0;
color_image_view.image = sc_buffer.image;
// Pre-set them to PRESENT_SRC_KHR, as the first thing we do after acquiring
// in image to render to will be to transition them away from that.
TransitionImageLayout2(cmdInit, sc_buffer.image, 0, 1,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
0, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
res = vkCreateImageView(vulkan_->GetDevice(), &color_image_view, nullptr, &sc_buffer.view);
swapchainImages_.push_back(sc_buffer);
assert(res == VK_SUCCESS);
}
delete[] swapchainImages;
// Must be before InitBackbufferRenderPass.
if (InitDepthStencilBuffer(cmdInit)) {
InitBackbufferFramebuffers(vulkan_->GetBackbufferWidth(), vulkan_->GetBackbufferHeight());
}
curWidth_ = -1;
curHeight_ = -1;
if (HasBackbuffers()) {
VLOG("Backbuffers Created");
}
// Start the thread.
if (useThread_ && HasBackbuffers()) {
run_ = true;
// Won't necessarily be 0.
threadInitFrame_ = vulkan_->GetCurFrame();
ILOG("Starting Vulkan submission thread (threadInitFrame_ = %d)", vulkan_->GetCurFrame());
thread_ = std::thread(&VulkanRenderManager::ThreadFunc, this);
}
}
Error MicroSwapchain::initInternal()
{
const VkDevice dev = m_factory->m_gr->getDevice();
// Get the surface size
VkSurfaceCapabilitiesKHR surfaceProperties;
U surfaceWidth = 0, surfaceHeight = 0;
{
ANKI_VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
m_factory->m_gr->getPhysicalDevice(), m_factory->m_gr->getSurface(), &surfaceProperties));
if(surfaceProperties.currentExtent.width == MAX_U32 || surfaceProperties.currentExtent.height == MAX_U32)
{
ANKI_VK_LOGE("Wrong surface size");
return Error::FUNCTION_FAILED;
}
surfaceWidth = surfaceProperties.currentExtent.width;
surfaceHeight = surfaceProperties.currentExtent.height;
}
// Get the surface format
VkFormat surfaceFormat = VK_FORMAT_END_RANGE;
VkColorSpaceKHR colorspace = VK_COLOR_SPACE_MAX_ENUM_KHR;
{
uint32_t formatCount;
ANKI_VK_CHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(
m_factory->m_gr->getPhysicalDevice(), m_factory->m_gr->getSurface(), &formatCount, nullptr));
DynamicArrayAuto<VkSurfaceFormatKHR> formats(getAllocator());
formats.create(formatCount);
ANKI_VK_CHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(
m_factory->m_gr->getPhysicalDevice(), m_factory->m_gr->getSurface(), &formatCount, &formats[0]));
while(formatCount--)
{
if(formats[formatCount].format == VK_FORMAT_B8G8R8A8_UNORM)
{
surfaceFormat = formats[formatCount].format;
colorspace = formats[formatCount].colorSpace;
break;
}
}
if(surfaceFormat == VK_FORMAT_UNDEFINED)
{
ANKI_VK_LOGE("Surface format not found");
return Error::FUNCTION_FAILED;
}
}
// Chose present mode
VkPresentModeKHR presentMode = VK_PRESENT_MODE_MAX_ENUM_KHR;
{
uint32_t presentModeCount;
vkGetPhysicalDeviceSurfacePresentModesKHR(
m_factory->m_gr->getPhysicalDevice(), m_factory->m_gr->getSurface(), &presentModeCount, nullptr);
presentModeCount = min(presentModeCount, 4u);
Array<VkPresentModeKHR, 4> presentModes;
vkGetPhysicalDeviceSurfacePresentModesKHR(
m_factory->m_gr->getPhysicalDevice(), m_factory->m_gr->getSurface(), &presentModeCount, &presentModes[0]);
if(m_factory->m_vsync)
{
presentMode = VK_PRESENT_MODE_FIFO_KHR;
}
else
{
for(U i = 0; i < presentModeCount; ++i)
{
if(presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR)
{
presentMode = VK_PRESENT_MODE_MAILBOX_KHR;
break;
}
else if(presentModes[i] == VK_PRESENT_MODE_IMMEDIATE_KHR)
{
presentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
break;
}
}
}
if(presentMode == VK_PRESENT_MODE_MAX_ENUM_KHR)
{
ANKI_VK_LOGE("Couldn't find a present mode");
return Error::FUNCTION_FAILED;
}
}
// Create swapchain
{
VkSwapchainCreateInfoKHR ci = {};
ci.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
ci.surface = m_factory->m_gr->getSurface();
ci.minImageCount = MAX_FRAMES_IN_FLIGHT;
ci.imageFormat = surfaceFormat;
ci.imageColorSpace = colorspace;
ci.imageExtent = surfaceProperties.currentExtent;
ci.imageArrayLayers = 1;
ci.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
ci.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
ci.queueFamilyIndexCount = 1;
U32 idx = m_factory->m_gr->getGraphicsQueueIndex();
ci.pQueueFamilyIndices = &idx;
ci.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
ci.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
ci.presentMode = presentMode;
ci.clipped = false;
ci.oldSwapchain = VK_NULL_HANDLE;
ANKI_VK_CHECK(vkCreateSwapchainKHR(dev, &ci, nullptr, &m_swapchain));
}
// Get images
{
uint32_t count = 0;
ANKI_VK_CHECK(vkGetSwapchainImagesKHR(dev, m_swapchain, &count, nullptr));
if(count != MAX_FRAMES_IN_FLIGHT)
{
ANKI_VK_LOGE("Requested a swapchain with %u images but got one with %u", MAX_FRAMES_IN_FLIGHT, count);
return Error::FUNCTION_FAILED;
}
ANKI_VK_LOGI("Created a swapchain. Image count: %u, present mode: %u, size: %ux%u, vsync: %u",
count,
presentMode,
surfaceWidth,
surfaceHeight,
U32(m_factory->m_vsync));
Array<VkImage, MAX_FRAMES_IN_FLIGHT> images;
ANKI_VK_CHECK(vkGetSwapchainImagesKHR(dev, m_swapchain, &count, &images[0]));
for(U i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i)
{
TextureInitInfo init("SwapchainImg");
init.m_width = surfaceWidth;
init.m_height = surfaceHeight;
init.m_format = Format::B8G8R8A8_UNORM;
ANKI_ASSERT(surfaceFormat == VK_FORMAT_B8G8R8A8_UNORM);
init.m_usage = TextureUsageBit::IMAGE_COMPUTE_WRITE | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE
| TextureUsageBit::PRESENT;
init.m_type = TextureType::_2D;
TextureImpl* tex =
m_factory->m_gr->getAllocator().newInstance<TextureImpl>(m_factory->m_gr, init.getName());
m_textures[i].reset(tex);
ANKI_CHECK(tex->initExternal(images[i], init));
}
}
return Error::NONE;
}
void create_vulkan_wm_swapchain(ReaperRoot& root, const VulkanBackend& backend, PresentationInfo& presentInfo)
{
REAPER_PROFILE_SCOPE("Vulkan", MP_RED);
log_debug(root, "vulkan: creating wm swapchain");
VkSwapchainCreateInfoKHR swap_chain_create_info = {
VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, // VkStructureType sType
nullptr, // const void *pNext
0, // VkSwapchainCreateFlagsKHR flags
presentInfo.surface, // VkSurfaceKHR surface
presentInfo.imageCount, // uint32_t minImageCount
presentInfo.surfaceFormat.format, // VkFormat imageFormat
presentInfo.surfaceFormat.colorSpace, // VkColorSpaceKHR imageColorSpace
presentInfo.surfaceExtent, // VkExtent2D imageExtent
1, // uint32_t imageArrayLayers
presentInfo.usageFlags, // VkImageUsageFlags imageUsage
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode imageSharingMode
0, // uint32_t queueFamilyIndexCount
nullptr, // const uint32_t *pQueueFamilyIndices
presentInfo.transform, // VkSurfaceTransformFlagBitsKHR preTransform
VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, // VkCompositeAlphaFlagBitsKHR compositeAlpha
presentInfo.presentMode, // VkPresentModeKHR presentMode
VK_TRUE, // VkBool32 clipped
VK_NULL_HANDLE // VkSwapchainKHR oldSwapchain
};
Assert(vkCreateSwapchainKHR(backend.device, &swap_chain_create_info, nullptr, &presentInfo.swapchain)
== VK_SUCCESS);
Assert(vkGetSwapchainImagesKHR(backend.device, presentInfo.swapchain, &presentInfo.imageCount, nullptr)
== VK_SUCCESS);
Assert(presentInfo.imageCount > 0);
presentInfo.images.resize(presentInfo.imageCount);
Assert(
vkGetSwapchainImagesKHR(backend.device, presentInfo.swapchain, &presentInfo.imageCount, &presentInfo.images[0])
== VK_SUCCESS);
VkSemaphoreCreateInfo semaphore_create_info = {
VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, // VkStructureType sType
nullptr, // const void* pNext
0 // VkSemaphoreCreateFlags flags
};
log_debug(root, "vulkan: create present renderpass");
create_swapchain_renderpass(backend, presentInfo);
create_swapchain_framebuffers(backend, presentInfo);
Assert(vkCreateSemaphore(backend.device, &semaphore_create_info, nullptr, &presentInfo.imageAvailableSemaphore)
== VK_SUCCESS);
log_debug(root, "vulkan: created semaphore with handle: {}",
static_cast<void*>(presentInfo.imageAvailableSemaphore));
Assert(vkCreateSemaphore(backend.device, &semaphore_create_info, nullptr, &presentInfo.renderingFinishedSemaphore)
== VK_SUCCESS);
log_debug(root, "vulkan: created semaphore with handle: {}",
static_cast<void*>(presentInfo.renderingFinishedSemaphore));
}
bool VkContext::CreateSwapchain(int width, int height) {
// Get surface capabilities
VkSurfaceCapabilitiesKHR surfaceCapabilities;
CheckVkResult(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physDev, surf, &surfaceCapabilities));
// Get surface formats
u32 formatCount = 0;
CheckVkResult(vkGetPhysicalDeviceSurfaceFormatsKHR(physDev, surf, &formatCount, nullptr));
std::vector<VkSurfaceFormatKHR> formats(formatCount);
CheckVkResult(vkGetPhysicalDeviceSurfaceFormatsKHR(physDev, surf, &formatCount, formats.data()));
// Get present modes
u32 presentModeCount;
CheckVkResult(vkGetPhysicalDeviceSurfacePresentModesKHR(physDev, surf, &presentModeCount, nullptr));
std::vector<VkPresentModeKHR> presentModes(presentModeCount);
CheckVkResult(vkGetPhysicalDeviceSurfacePresentModesKHR(physDev, surf, &presentModeCount, presentModes.data()));
// Select number of swapchain images
u32 imageCount = surfaceCapabilities.minImageCount + 1;
if (surfaceCapabilities.maxImageCount != 0 && imageCount > surfaceCapabilities.maxImageCount) {
imageCount = surfaceCapabilities.maxImageCount;
}
// Select format
VkSurfaceFormatKHR format;
if (formats.size() == 1 && formats[0].format == VK_FORMAT_UNDEFINED) {
format.format = VK_FORMAT_R8G8B8A8_UNORM;
format.colorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
}
else {
for (u32 i = 0; i < formats.size(); i++)
{
if (formats[i].format == VK_FORMAT_R8G8B8A8_UNORM) {
format = formats[i];
}
}
format = formats[0];
}
// Select extent
VkExtent2D extent;
if (surfaceCapabilities.currentExtent.width == -1) {
extent.width = min(max((u32)width, surfaceCapabilities.minImageExtent.width), surfaceCapabilities.maxImageExtent.width);
extent.height = min(max((u32)height, surfaceCapabilities.minImageExtent.height), surfaceCapabilities.maxImageExtent.height);
}
else {
extent = surfaceCapabilities.currentExtent;
}
// Select present mode (FIFO by default)
VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;
// Choose mailbox if possible
for (u32 i = 0; i < presentModes.size(); i++)
{
if (presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR) {
presentMode = presentModes[i];
}
}
// Select transformation
VkSurfaceTransformFlagBitsKHR transform;
if (surfaceCapabilities.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) {
transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
}
else {
transform = surfaceCapabilities.currentTransform;
}
// Check if image transfer destination is supported
if (!(surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT)) {
std::cout << "Image transfer destination not supported" << std::endl;
return false;
}
// Create swapchian
VkSwapchainCreateInfoKHR swapchainInfo = {};
swapchainInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
swapchainInfo.surface = surf;
swapchainInfo.minImageCount = imageCount;
swapchainInfo.imageFormat = format.format;
swapchainInfo.imageColorSpace = format.colorSpace;
swapchainInfo.imageExtent = extent;
swapchainInfo.imageArrayLayers = 1;
swapchainInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
swapchainInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
swapchainInfo.queueFamilyIndexCount = 0;
swapchainInfo.pQueueFamilyIndices = nullptr;
swapchainInfo.preTransform = transform;
swapchainInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
swapchainInfo.presentMode = presentMode;
swapchainInfo.clipped = VK_TRUE;
swapchainInfo.oldSwapchain = VK_NULL_HANDLE;
CheckVkResult(vkCreateSwapchainKHR(dev, &swapchainInfo, nullptr, &swapchain));
// Get swapchain images
u32 swapchainImageCount = 0;
CheckVkResult(vkGetSwapchainImagesKHR(dev, swapchain, &swapchainImageCount, nullptr));
swapchainImages.resize(swapchainImageCount);
CheckVkResult(vkGetSwapchainImagesKHR(dev, swapchain, &swapchainImageCount, swapchainImages.data()));
// Create swapchain image views
swapchainImageViews.resize(imageCount);
for (u32 i = 0; i < imageCount; i++) {
VkImageViewCreateInfo imageViewCreateInfo = {};
imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
imageViewCreateInfo.image = swapchainImages[i];
imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
imageViewCreateInfo.format = format.format;
imageViewCreateInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
imageViewCreateInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
imageViewCreateInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
imageViewCreateInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageViewCreateInfo.subresourceRange.baseMipLevel = 0;
imageViewCreateInfo.subresourceRange.levelCount = 1;
imageViewCreateInfo.subresourceRange.baseArrayLayer = 0;
imageViewCreateInfo.subresourceRange.layerCount = 1;
CheckVkResult(vkCreateImageView(dev, &imageViewCreateInfo, nullptr, &swapchainImageViews[i]));
}
return true;
}
Error GrManagerImpl::initSwapchain(const GrManagerInitInfo& init)
{
VkSurfaceCapabilitiesKHR surfaceProperties;
ANKI_VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(m_physicalDevice, m_surface, &surfaceProperties));
if(surfaceProperties.currentExtent.width == MAX_U32 || surfaceProperties.currentExtent.height == MAX_U32)
{
ANKI_LOGE("Wrong surface size");
return ErrorCode::FUNCTION_FAILED;
}
m_surfaceWidth = surfaceProperties.currentExtent.width;
m_surfaceHeight = surfaceProperties.currentExtent.height;
uint32_t formatCount;
ANKI_VK_CHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(m_physicalDevice, m_surface, &formatCount, nullptr));
DynamicArrayAuto<VkSurfaceFormatKHR> formats(getAllocator());
formats.create(formatCount);
ANKI_VK_CHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(m_physicalDevice, m_surface, &formatCount, &formats[0]));
VkColorSpaceKHR colorspace = VK_COLOR_SPACE_MAX_ENUM_KHR;
while(formatCount--)
{
if(formats[formatCount].format == VK_FORMAT_B8G8R8A8_UNORM)
{
m_surfaceFormat = formats[formatCount].format;
colorspace = formats[formatCount].colorSpace;
break;
}
}
if(m_surfaceFormat == VK_FORMAT_UNDEFINED)
{
ANKI_LOGE("Surface format not found");
return ErrorCode::FUNCTION_FAILED;
}
// Chose present mode
uint32_t presentModeCount;
vkGetPhysicalDeviceSurfacePresentModesKHR(m_physicalDevice, m_surface, &presentModeCount, nullptr);
presentModeCount = min(presentModeCount, 4u);
Array<VkPresentModeKHR, 4> presentModes;
vkGetPhysicalDeviceSurfacePresentModesKHR(m_physicalDevice, m_surface, &presentModeCount, &presentModes[0]);
VkPresentModeKHR presentMode = VK_PRESENT_MODE_MAX_ENUM_KHR;
if(init.m_config->getNumber("vsync"))
{
presentMode = VK_PRESENT_MODE_FIFO_KHR;
}
else
{
for(U i = 0; i < presentModeCount; ++i)
{
if(presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR)
{
presentMode = VK_PRESENT_MODE_MAILBOX_KHR;
break;
}
else if(presentModes[i] == VK_PRESENT_MODE_IMMEDIATE_KHR)
{
presentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
break;
}
}
}
if(presentMode == VK_PRESENT_MODE_MAX_ENUM_KHR)
{
ANKI_LOGE("VK: Couldn't find a present mode");
return ErrorCode::FUNCTION_FAILED;
}
// Create swapchain
VkSwapchainCreateInfoKHR ci = {};
ci.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
ci.surface = m_surface;
ci.minImageCount = MAX_FRAMES_IN_FLIGHT;
ci.imageFormat = m_surfaceFormat;
ci.imageColorSpace = colorspace;
ci.imageExtent = surfaceProperties.currentExtent;
ci.imageArrayLayers = 1;
ci.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
ci.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
ci.queueFamilyIndexCount = 1;
ci.pQueueFamilyIndices = &m_queueIdx;
ci.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
ci.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
ci.presentMode = presentMode;
ci.clipped = false;
ci.oldSwapchain = VK_NULL_HANDLE;
ANKI_VK_CHECK(vkCreateSwapchainKHR(m_device, &ci, nullptr, &m_swapchain));
// Get images
uint32_t count = 0;
ANKI_VK_CHECK(vkGetSwapchainImagesKHR(m_device, m_swapchain, &count, nullptr));
if(count != MAX_FRAMES_IN_FLIGHT)
{
ANKI_LOGE("Requested a swapchain with %u images but got one with %u", MAX_FRAMES_IN_FLIGHT, count);
return ErrorCode::FUNCTION_FAILED;
}
ANKI_LOGI("VK: Created a swapchain. Image count: %u, present mode: %u", count, presentMode);
Array<VkImage, MAX_FRAMES_IN_FLIGHT> images;
ANKI_VK_CHECK(vkGetSwapchainImagesKHR(m_device, m_swapchain, &count, &images[0]));
for(U i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i)
{
m_backbuffers[i].m_image = images[i];
ANKI_ASSERT(images[i]);
}
// Create img views
for(U i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i)
{
VkImageViewCreateInfo ci = {};
ci.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
ci.flags = 0;
ci.image = m_backbuffers[i].m_image;
ci.viewType = VK_IMAGE_VIEW_TYPE_2D;
ci.format = m_surfaceFormat;
ci.components = {
VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A};
ci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
ci.subresourceRange.baseMipLevel = 0;
ci.subresourceRange.levelCount = 1;
ci.subresourceRange.baseArrayLayer = 0;
ci.subresourceRange.layerCount = 1;
ANKI_VK_CHECK(vkCreateImageView(m_device, &ci, nullptr, &m_backbuffers[i].m_imageView));
}
return ErrorCode::NONE;
}