kbz_8/KVF
1
0
Fork 0
Code Issues Pull Requests actions.actions Packages Projects Releases 1 Wiki Activity

adding define option to disable all KHR functions

Browse Source
This commit is contained in:
kbz_8
2024-09-12 23:33:34 +02:00
parent 1a734cd185
commit 6333bc667c
1 changed files with 224 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

426
kvf.h
View File

@@ -43,6 +43,8 @@
* or VK_NO_PROTOTYPES before including this file to avoid conflicts with Vulkan prototypes. * or VK_NO_PROTOTYPES before including this file to avoid conflicts with Vulkan prototypes.
* *
* You can also #define KVF_ENABLE_VALIDATION_LAYERS to enable validation layers. * You can also #define KVF_ENABLE_VALIDATION_LAYERS to enable validation layers.
*
* Use #define KVF_NO_KHR to remove all functions that use KHR calls.
*/ */
#ifndef KBZ_8_VULKAN_FRAMEWORK_H #ifndef KBZ_8_VULKAN_FRAMEWORK_H
@@ -99,11 +101,15 @@ VkPhysicalDevice kvfPickGoodPhysicalDevice(VkInstance instance, VkSurfaceKHR sur
VkQueue kvfGetDeviceQueue(VkDevice device, KvfQueueType queue); VkQueue kvfGetDeviceQueue(VkDevice device, KvfQueueType queue);
uint32_t kvfGetDeviceQueueFamily(VkDevice device, KvfQueueType queue); uint32_t kvfGetDeviceQueueFamily(VkDevice device, KvfQueueType queue);
bool kvfQueuePresentKHR(VkDevice device, VkSemaphore wait, VkSwapchainKHR swapchain, uint32_t image_index); // return false when the swapchain must be recreated #ifndef KVF_NO_KHR
bool kvfQueuePresentKHR(VkDevice device, VkSemaphore wait, VkSwapchainKHR swapchain, uint32_t image_index); // return false when the swapchain must be recreated
#endif
// Meant to be used when creating a VkDevice with a custom VkPhysicalDevice // Meant to be used when creating a VkDevice with a custom VkPhysicalDevice
int32_t kvfFindDeviceQueueFamily(VkPhysicalDevice physical, KvfQueueType type); // This function cannot find present queue int32_t kvfFindDeviceQueueFamily(VkPhysicalDevice physical, KvfQueueType type); // This function cannot find present queue
int32_t kvfFindDeviceQueueFamilyKHR(VkPhysicalDevice physical, VkSurfaceKHR surface, KvfQueueType type); // This one can find present queue #ifndef KVF_NO_KHR
int32_t kvfFindDeviceQueueFamilyKHR(VkPhysicalDevice physical, VkSurfaceKHR surface, KvfQueueType type); // This one can find present queue
#endif
VkDevice kvfCreateDefaultDevice(VkPhysicalDevice physical); VkDevice kvfCreateDefaultDevice(VkPhysicalDevice physical);
VkDevice kvfCreateDevice(VkPhysicalDevice physical, const char** extensions, uint32_t extensions_count, VkPhysicalDeviceFeatures* features); VkDevice kvfCreateDevice(VkPhysicalDevice physical, const char** extensions, uint32_t extensions_count, VkPhysicalDeviceFeatures* features);
@@ -118,12 +124,14 @@ void kvfDestroyFence(VkDevice device, VkFence fence);
VkSemaphore kvfCreateSemaphore(VkDevice device); VkSemaphore kvfCreateSemaphore(VkDevice device);
void kvfDestroySemaphore(VkDevice device, VkSemaphore semaphore); void kvfDestroySemaphore(VkDevice device, VkSemaphore semaphore);
VkSwapchainKHR kvfCreateSwapchainKHR(VkDevice device, VkPhysicalDevice physical, VkSurfaceKHR surface, VkExtent2D extent, bool try_vsync); #ifndef KVF_NO_KHR
VkFormat kvfGetSwapchainImagesFormat(VkSwapchainKHR swapchain); VkSwapchainKHR kvfCreateSwapchainKHR(VkDevice device, VkPhysicalDevice physical, VkSurfaceKHR surface, VkExtent2D extent, bool try_vsync);
uint32_t kvfGetSwapchainImagesCount(VkSwapchainKHR swapchain); VkFormat kvfGetSwapchainImagesFormat(VkSwapchainKHR swapchain);
uint32_t kvfGetSwapchainMinImagesCount(VkSwapchainKHR swapchain); uint32_t kvfGetSwapchainImagesCount(VkSwapchainKHR swapchain);
VkExtent2D kvfGetSwapchainImagesSize(VkSwapchainKHR swapchain); uint32_t kvfGetSwapchainMinImagesCount(VkSwapchainKHR swapchain);
void kvfDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain); VkExtent2D kvfGetSwapchainImagesSize(VkSwapchainKHR swapchain);
void kvfDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain);
#endif
VkImage kvfCreateImage(VkDevice device, uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, KvfImageType type); VkImage kvfCreateImage(VkDevice device, uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, KvfImageType type);
void kvfImageToBuffer(VkCommandBuffer cmd, VkBuffer dst, VkImage src, size_t buffer_offset, VkImageAspectFlagBits aspect, VkExtent3D extent); void kvfImageToBuffer(VkCommandBuffer cmd, VkBuffer dst, VkImage src, size_t buffer_offset, VkImageAspectFlagBits aspect, VkExtent3D extent);
@@ -151,7 +159,9 @@ void kvfSubmitCommandBuffer(VkDevice device, VkCommandBuffer buffer, KvfQueueTyp
void kvfSubmitSingleTimeCommandBuffer(VkDevice device, VkCommandBuffer buffer, KvfQueueType queue, VkFence fence); void kvfSubmitSingleTimeCommandBuffer(VkDevice device, VkCommandBuffer buffer, KvfQueueType queue, VkFence fence);
VkAttachmentDescription kvfBuildAttachmentDescription(KvfImageType type, VkFormat format, VkImageLayout initial, VkImageLayout final, bool clear, VkSampleCountFlagBits samples); VkAttachmentDescription kvfBuildAttachmentDescription(KvfImageType type, VkFormat format, VkImageLayout initial, VkImageLayout final, bool clear, VkSampleCountFlagBits samples);
VkAttachmentDescription kvfBuildSwapchainAttachmentDescription(VkSwapchainKHR swapchain, bool clear); #ifndef KVF_NO_KHR
VkAttachmentDescription kvfBuildSwapchainAttachmentDescription(VkSwapchainKHR swapchain, bool clear);
#endif
VkRenderPass kvfCreateRenderPass(VkDevice device, VkAttachmentDescription* attachments, size_t attachments_count, VkPipelineBindPoint bind_point); VkRenderPass kvfCreateRenderPass(VkDevice device, VkAttachmentDescription* attachments, size_t attachments_count, VkPipelineBindPoint bind_point);
VkRenderPass kvfCreateRenderPassWithSubpassDependencies(VkDevice device, VkAttachmentDescription* attachments, size_t attachments_count, VkPipelineBindPoint bind_point, VkSubpassDependency* dependencies, size_t dependencies_count); VkRenderPass kvfCreateRenderPassWithSubpassDependencies(VkDevice device, VkAttachmentDescription* attachments, size_t attachments_count, VkPipelineBindPoint bind_point, VkSubpassDependency* dependencies, size_t dependencies_count);
@@ -1128,14 +1138,16 @@ __KvfQueueFamilies __kvfFindQueueFamilies(VkPhysicalDevice physical, VkSurfaceKH
if(queue_families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) if(queue_families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)
queues.graphics = i; queues.graphics = i;
VkBool32 present_support = false; VkBool32 present_support = false;
if(surface != VK_NULL_HANDLE) #ifndef KVF_NO_KHR
{ if(surface != VK_NULL_HANDLE)
vkGetPhysicalDeviceSurfaceSupportKHR(physical, i, surface, &present_support); {
if(present_support) vkGetPhysicalDeviceSurfaceSupportKHR(physical, i, surface, &present_support);
queues.present = i; if(present_support)
if(queues.graphics != -1 && queues.present != -1 && queues.compute != -1) queues.present = i;
break; if(queues.graphics != -1 && queues.present != -1 && queues.compute != -1)
} break;
}
#endif
else if(queues.graphics != -1 && queues.compute != -1) else if(queues.graphics != -1 && queues.compute != -1)
break; break;
} }
@@ -1202,14 +1214,16 @@ int32_t __kvfScorePhysicalDevice(VkPhysicalDevice device, VkSurfaceKHR surface,
if(queues.graphics == -1 || (surface != VK_NULL_HANDLE && queues.present == -1)) if(queues.graphics == -1 || (surface != VK_NULL_HANDLE && queues.present == -1))
return -1; return -1;
if(surface != VK_NULL_HANDLE) #ifndef KVF_NO_KHR
{ if(surface != VK_NULL_HANDLE)
/* Check surface formats counts */ {
uint32_t format_count; /* Check surface formats counts */
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &format_count, NULL); uint32_t format_count;
if(format_count == 0) vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &format_count, NULL);
return -1; if(format_count == 0)
} return -1;
}
#endif
VkPhysicalDeviceProperties device_props; VkPhysicalDeviceProperties device_props;
vkGetPhysicalDeviceProperties(device, &device_props); vkGetPhysicalDeviceProperties(device, &device_props);
@@ -1401,23 +1415,25 @@ uint32_t kvfGetDeviceQueueFamily(VkDevice device, KvfQueueType queue)
return 0; return 0;
} }
bool kvfQueuePresentKHR(VkDevice device, VkSemaphore wait, VkSwapchainKHR swapchain, uint32_t image_index) #ifndef KVF_NO_KHR
{ bool kvfQueuePresentKHR(VkDevice device, VkSemaphore wait, VkSwapchainKHR swapchain, uint32_t image_index)
KVF_ASSERT(device != VK_NULL_HANDLE); {
VkPresentInfoKHR present_info = {}; KVF_ASSERT(device != VK_NULL_HANDLE);
present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; VkPresentInfoKHR present_info = {};
present_info.waitSemaphoreCount = 1; present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
present_info.pWaitSemaphores = &wait; present_info.waitSemaphoreCount = 1;
present_info.swapchainCount = 1; present_info.pWaitSemaphores = &wait;
present_info.pSwapchains = &swapchain; present_info.swapchainCount = 1;
present_info.pImageIndices = &image_index; present_info.pSwapchains = &swapchain;
VkResult result = vkQueuePresentKHR(kvfGetDeviceQueue(device, KVF_PRESENT_QUEUE), &present_info); present_info.pImageIndices = &image_index;
if(result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR) VkResult result = vkQueuePresentKHR(kvfGetDeviceQueue(device, KVF_PRESENT_QUEUE), &present_info);
return false; if(result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR)
else return false;
__kvfCheckVk(result); else
return true; __kvfCheckVk(result);
} return true;
}
#endif
int32_t kvfFindDeviceQueueFamily(VkPhysicalDevice physical, KvfQueueType type) int32_t kvfFindDeviceQueueFamily(VkPhysicalDevice physical, KvfQueueType type)
{ {
@@ -1453,33 +1469,35 @@ int32_t kvfFindDeviceQueueFamily(VkPhysicalDevice physical, KvfQueueType type)
return queue; return queue;
} }
int32_t kvfFindDeviceQueueFamilyKHR(VkPhysicalDevice physical, VkSurfaceKHR surface, KvfQueueType type) #ifndef KVF_NO_KHR
{ int32_t kvfFindDeviceQueueFamilyKHR(VkPhysicalDevice physical, VkSurfaceKHR surface, KvfQueueType type)
KVF_ASSERT(physical != VK_NULL_HANDLE);
KVF_ASSERT(surface != VK_NULL_HANDLE);
if(type != KVF_PRESENT_QUEUE)
return kvfFindDeviceQueueFamily(physical, type);
uint32_t queue_family_count;
vkGetPhysicalDeviceQueueFamilyProperties(physical, &queue_family_count, NULL);
VkQueueFamilyProperties* queue_families = (VkQueueFamilyProperties*)KVF_MALLOC(sizeof(VkQueueFamilyProperties) * queue_family_count);
vkGetPhysicalDeviceQueueFamilyProperties(physical, &queue_family_count, queue_families);
int32_t queue = -1;
for(int i = 0; i < queue_family_count; i++)
{ {
VkBool32 present_support = false; KVF_ASSERT(physical != VK_NULL_HANDLE);
vkGetPhysicalDeviceSurfaceSupportKHR(physical, i, surface, &present_support); KVF_ASSERT(surface != VK_NULL_HANDLE);
if(present_support)
queue = i; if(type != KVF_PRESENT_QUEUE)
if(queue != -1) return kvfFindDeviceQueueFamily(physical, type);
break;
uint32_t queue_family_count;
vkGetPhysicalDeviceQueueFamilyProperties(physical, &queue_family_count, NULL);
VkQueueFamilyProperties* queue_families = (VkQueueFamilyProperties*)KVF_MALLOC(sizeof(VkQueueFamilyProperties) * queue_family_count);
vkGetPhysicalDeviceQueueFamilyProperties(physical, &queue_family_count, queue_families);
int32_t queue = -1;
for(int i = 0; i < queue_family_count; i++)
{
VkBool32 present_support = false;
vkGetPhysicalDeviceSurfaceSupportKHR(physical, i, surface, &present_support);
if(present_support)
queue = i;
if(queue != -1)
break;
}
KVF_FREE(queue_families);
return queue;
} }
KVF_FREE(queue_families); #endif
return queue;
}
VkFence kvfCreateFence(VkDevice device) VkFence kvfCreateFence(VkDevice device)
{ {
@@ -1525,151 +1543,153 @@ void kvfDestroySemaphore(VkDevice device, VkSemaphore semaphore)
vkDestroySemaphore(device, semaphore, NULL); vkDestroySemaphore(device, semaphore, NULL);
} }
__KvfSwapchainSupportInternal __kvfQuerySwapchainSupport(VkPhysicalDevice physical, VkSurfaceKHR surface) #ifndef KVF_NO_KHR
{ __KvfSwapchainSupportInternal __kvfQuerySwapchainSupport(VkPhysicalDevice physical, VkSurfaceKHR surface)
__KvfSwapchainSupportInternal support;
__kvfCheckVk(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical, surface, &support.capabilities));
vkGetPhysicalDeviceSurfaceFormatsKHR(physical, surface, &support.formats_count, NULL);
if(support.formats_count != 0)
{ {
support.formats = (VkSurfaceFormatKHR*)KVF_MALLOC(sizeof(VkSurfaceFormatKHR) * support.formats_count); __KvfSwapchainSupportInternal support;
vkGetPhysicalDeviceSurfaceFormatsKHR(physical, surface, &support.formats_count, support.formats);
__kvfCheckVk(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical, surface, &support.capabilities));
vkGetPhysicalDeviceSurfaceFormatsKHR(physical, surface, &support.formats_count, NULL);
if(support.formats_count != 0)
{
support.formats = (VkSurfaceFormatKHR*)KVF_MALLOC(sizeof(VkSurfaceFormatKHR) * support.formats_count);
vkGetPhysicalDeviceSurfaceFormatsKHR(physical, surface, &support.formats_count, support.formats);
}
vkGetPhysicalDeviceSurfacePresentModesKHR(physical, surface, &support.presentModes_count, NULL);
if(support.presentModes_count != 0)
{
support.presentModes = (VkPresentModeKHR*)KVF_MALLOC(sizeof(VkPresentModeKHR) * support.presentModes_count);
vkGetPhysicalDeviceSurfacePresentModesKHR(physical, surface, &support.presentModes_count, support.presentModes);
}
return support;
} }
vkGetPhysicalDeviceSurfacePresentModesKHR(physical, surface, &support.presentModes_count, NULL); VkSurfaceFormatKHR __kvfChooseSwapSurfaceFormat(__KvfSwapchainSupportInternal* support)
if(support.presentModes_count != 0)
{ {
support.presentModes = (VkPresentModeKHR*)KVF_MALLOC(sizeof(VkPresentModeKHR) * support.presentModes_count); for(int i = 0; i < support->formats_count; i++)
vkGetPhysicalDeviceSurfacePresentModesKHR(physical, surface, &support.presentModes_count, support.presentModes); {
} if(support->formats[i].format == VK_FORMAT_R8G8B8A8_SRGB && support->formats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
return support; return support->formats[i];
} }
return support->formats[0];
VkSurfaceFormatKHR __kvfChooseSwapSurfaceFormat(__KvfSwapchainSupportInternal* support)
{
for(int i = 0; i < support->formats_count; i++)
{
if(support->formats[i].format == VK_FORMAT_R8G8B8A8_SRGB && support->formats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
return support->formats[i];
}
return support->formats[0];
}
VkPresentModeKHR __kvfChooseSwapPresentMode(__KvfSwapchainSupportInternal* support, bool try_vsync)
{
if(try_vsync == false)
return VK_PRESENT_MODE_IMMEDIATE_KHR;
for(int i = 0; i < support->presentModes_count; i++)
{
if(support->presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR)
return support->presentModes[i];
}
return VK_PRESENT_MODE_FIFO_KHR;
}
uint32_t __kvfClamp(uint32_t i, uint32_t min, uint32_t max)
{
const uint32_t t = i < min ? min : i;
return t > max ? max : t;
}
VkSwapchainKHR kvfCreateSwapchainKHR(VkDevice device, VkPhysicalDevice physical, VkSurfaceKHR surface, VkExtent2D extent, bool try_vsync)
{
KVF_ASSERT(device != VK_NULL_HANDLE);
VkSwapchainKHR swapchain;
__KvfSwapchainSupportInternal support = __kvfQuerySwapchainSupport(physical, surface);
VkSurfaceFormatKHR surfaceFormat = __kvfChooseSwapSurfaceFormat(&support);
VkPresentModeKHR presentMode = __kvfChooseSwapPresentMode(&support, try_vsync);
uint32_t image_count = support.capabilities.minImageCount + 1;
if(support.capabilities.maxImageCount > 0 && image_count > support.capabilities.maxImageCount)
image_count = support.capabilities.maxImageCount;
__KvfDevice* kvfdevice = __kvfGetKvfDeviceFromVkDevice(device);
KVF_ASSERT(kvfdevice != NULL);
uint32_t queue_family_indices[] = { (uint32_t)kvfdevice->queues.graphics, (uint32_t)kvfdevice->queues.present };
if(support.capabilities.currentExtent.width != UINT32_MAX)
extent = support.capabilities.currentExtent;
else
{
extent.width = __kvfClamp(extent.width, support.capabilities.minImageExtent.width, support.capabilities.maxImageExtent.width);
extent.height = __kvfClamp(extent.height, support.capabilities.minImageExtent.height, support.capabilities.maxImageExtent.height);
} }
VkSwapchainCreateInfoKHR createInfo = {}; VkPresentModeKHR __kvfChooseSwapPresentMode(__KvfSwapchainSupportInternal* support, bool try_vsync)
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
createInfo.surface = surface;
createInfo.minImageCount = image_count;
createInfo.imageFormat = surfaceFormat.format;
createInfo.imageColorSpace = surfaceFormat.colorSpace;
createInfo.imageExtent = extent;
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
createInfo.preTransform = support.capabilities.currentTransform;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
createInfo.presentMode = presentMode;
createInfo.clipped = VK_TRUE;
createInfo.oldSwapchain = VK_NULL_HANDLE;
if(kvfdevice->queues.graphics != kvfdevice->queues.present)
{ {
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT; if(try_vsync == false)
createInfo.queueFamilyIndexCount = 2; return VK_PRESENT_MODE_IMMEDIATE_KHR;
createInfo.pQueueFamilyIndices = queue_family_indices; for(int i = 0; i < support->presentModes_count; i++)
{
if(support->presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR)
return support->presentModes[i];
}
return VK_PRESENT_MODE_FIFO_KHR;
} }
else
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
__kvfCheckVk(vkCreateSwapchainKHR(device, &createInfo, NULL, &swapchain)); uint32_t __kvfClamp(uint32_t i, uint32_t min, uint32_t max)
{
const uint32_t t = i < min ? min : i;
return t > max ? max : t;
}
uint32_t images_count; VkSwapchainKHR kvfCreateSwapchainKHR(VkDevice device, VkPhysicalDevice physical, VkSurfaceKHR surface, VkExtent2D extent, bool try_vsync)
vkGetSwapchainImagesKHR(device, swapchain, (uint32_t*)&images_count, NULL); {
KVF_ASSERT(device != VK_NULL_HANDLE);
VkSwapchainKHR swapchain;
__KvfSwapchainSupportInternal support = __kvfQuerySwapchainSupport(physical, surface);
__kvfAddSwapchainToArray(swapchain, support, surfaceFormat.format, images_count, extent); VkSurfaceFormatKHR surfaceFormat = __kvfChooseSwapSurfaceFormat(&support);
VkPresentModeKHR presentMode = __kvfChooseSwapPresentMode(&support, try_vsync);
return swapchain; uint32_t image_count = support.capabilities.minImageCount + 1;
} if(support.capabilities.maxImageCount > 0 && image_count > support.capabilities.maxImageCount)
image_count = support.capabilities.maxImageCount;
VkFormat kvfGetSwapchainImagesFormat(VkSwapchainKHR swapchain) __KvfDevice* kvfdevice = __kvfGetKvfDeviceFromVkDevice(device);
{ KVF_ASSERT(kvfdevice != NULL);
__KvfSwapchain* kvf_swapchain = __kvfGetKvfSwapchainFromVkSwapchainKHR(swapchain);
KVF_ASSERT(kvf_swapchain != NULL);
return kvf_swapchain->images_format;
}
uint32_t kvfGetSwapchainImagesCount(VkSwapchainKHR swapchain) uint32_t queue_family_indices[] = { (uint32_t)kvfdevice->queues.graphics, (uint32_t)kvfdevice->queues.present };
{
__KvfSwapchain* kvf_swapchain = __kvfGetKvfSwapchainFromVkSwapchainKHR(swapchain);
KVF_ASSERT(kvf_swapchain != NULL);
return kvf_swapchain->images_count;
}
uint32_t kvfGetSwapchainMinImagesCount(VkSwapchainKHR swapchain) if(support.capabilities.currentExtent.width != UINT32_MAX)
{ extent = support.capabilities.currentExtent;
__KvfSwapchain* kvf_swapchain = __kvfGetKvfSwapchainFromVkSwapchainKHR(swapchain); else
KVF_ASSERT(kvf_swapchain != NULL); {
return kvf_swapchain->support.capabilities.minImageCount; extent.width = __kvfClamp(extent.width, support.capabilities.minImageExtent.width, support.capabilities.maxImageExtent.width);
} extent.height = __kvfClamp(extent.height, support.capabilities.minImageExtent.height, support.capabilities.maxImageExtent.height);
}
VkExtent2D kvfGetSwapchainImagesSize(VkSwapchainKHR swapchain) VkSwapchainCreateInfoKHR createInfo = {};
{ createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
__KvfSwapchain* kvf_swapchain = __kvfGetKvfSwapchainFromVkSwapchainKHR(swapchain); createInfo.surface = surface;
KVF_ASSERT(kvf_swapchain != NULL); createInfo.minImageCount = image_count;
return kvf_swapchain->images_extent; createInfo.imageFormat = surfaceFormat.format;
} createInfo.imageColorSpace = surfaceFormat.colorSpace;
createInfo.imageExtent = extent;
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
createInfo.preTransform = support.capabilities.currentTransform;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
createInfo.presentMode = presentMode;
createInfo.clipped = VK_TRUE;
createInfo.oldSwapchain = VK_NULL_HANDLE;
void kvfDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain) if(kvfdevice->queues.graphics != kvfdevice->queues.present)
{ {
if(swapchain == VK_NULL_HANDLE) createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
return; createInfo.queueFamilyIndexCount = 2;
KVF_ASSERT(device != VK_NULL_HANDLE); createInfo.pQueueFamilyIndices = queue_family_indices;
__kvfDestroySwapchain(device, swapchain); }
} else
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
__kvfCheckVk(vkCreateSwapchainKHR(device, &createInfo, NULL, &swapchain));
uint32_t images_count;
vkGetSwapchainImagesKHR(device, swapchain, (uint32_t*)&images_count, NULL);
__kvfAddSwapchainToArray(swapchain, support, surfaceFormat.format, images_count, extent);
return swapchain;
}
VkFormat kvfGetSwapchainImagesFormat(VkSwapchainKHR swapchain)
{
__KvfSwapchain* kvf_swapchain = __kvfGetKvfSwapchainFromVkSwapchainKHR(swapchain);
KVF_ASSERT(kvf_swapchain != NULL);
return kvf_swapchain->images_format;
}
uint32_t kvfGetSwapchainImagesCount(VkSwapchainKHR swapchain)
{
__KvfSwapchain* kvf_swapchain = __kvfGetKvfSwapchainFromVkSwapchainKHR(swapchain);
KVF_ASSERT(kvf_swapchain != NULL);
return kvf_swapchain->images_count;
}
uint32_t kvfGetSwapchainMinImagesCount(VkSwapchainKHR swapchain)
{
__KvfSwapchain* kvf_swapchain = __kvfGetKvfSwapchainFromVkSwapchainKHR(swapchain);
KVF_ASSERT(kvf_swapchain != NULL);
return kvf_swapchain->support.capabilities.minImageCount;
}
VkExtent2D kvfGetSwapchainImagesSize(VkSwapchainKHR swapchain)
{
__KvfSwapchain* kvf_swapchain = __kvfGetKvfSwapchainFromVkSwapchainKHR(swapchain);
KVF_ASSERT(kvf_swapchain != NULL);
return kvf_swapchain->images_extent;
}
void kvfDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain)
{
if(swapchain == VK_NULL_HANDLE)
return;
KVF_ASSERT(device != VK_NULL_HANDLE);
__kvfDestroySwapchain(device, swapchain);
}
#endif
VkImage kvfCreateImage(VkDevice device, uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, KvfImageType type) VkImage kvfCreateImage(VkDevice device, uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, KvfImageType type)
{ {
@@ -2051,13 +2071,15 @@ VkAttachmentDescription kvfBuildAttachmentDescription(KvfImageType type, VkForma
return attachment; return attachment;
} }
VkAttachmentDescription kvfBuildSwapchainAttachmentDescription(VkSwapchainKHR swapchain, bool clear) #ifndef KVF_NO_KHR
{ VkAttachmentDescription kvfBuildSwapchainAttachmentDescription(VkSwapchainKHR swapchain, bool clear)
__KvfSwapchain* kvf_swapchain = __kvfGetKvfSwapchainFromVkSwapchainKHR(swapchain); {
KVF_ASSERT(kvf_swapchain != NULL); __KvfSwapchain* kvf_swapchain = __kvfGetKvfSwapchainFromVkSwapchainKHR(swapchain);
KVF_ASSERT(kvf_swapchain->images_count != 0); KVF_ASSERT(kvf_swapchain != NULL);
return kvfBuildAttachmentDescription(KVF_IMAGE_COLOR, kvf_swapchain->images_format, VK_IMAGE_LAYOUT_UNDEFINED,VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, clear, VK_SAMPLE_COUNT_1_BIT); KVF_ASSERT(kvf_swapchain->images_count != 0);
} return kvfBuildAttachmentDescription(KVF_IMAGE_COLOR, kvf_swapchain->images_format, VK_IMAGE_LAYOUT_UNDEFINED,VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, clear, VK_SAMPLE_COUNT_1_BIT);
}
#endif
VkRenderPass kvfCreateRenderPass(VkDevice device, VkAttachmentDescription* attachments, size_t attachments_count, VkPipelineBindPoint bind_point) VkRenderPass kvfCreateRenderPass(VkDevice device, VkAttachmentDescription* attachments, size_t attachments_count, VkPipelineBindPoint bind_point)
{ {