9#include <vulkan/vulkan_core.h>
12#define VOLK_NO_DEVICE_PROTOTYPES
13#define VK_NO_PROTOTYPES
15# define VK_USE_PLATFORM_WIN32_KHR
16#elif defined(__APPLE__)
17# define VK_USE_PLATFORM_METAL_EXT
20# define VK_USE_PLATFORM_XLIB_KHR
22# ifdef WITH_GHOST_WAYLAND
23# define VK_USE_PLATFORM_WAYLAND_KHR
29# include <SDL3/SDL_vulkan.h>
37#if !defined(_WIN32) or defined(_M_ARM64)
39# define VMA_EXTERNAL_MEMORY_WIN32 0
41#include "vk_mem_alloc.h"
68#define VK_CHECK(__expression, fail_value) \
70 VkResult r = (__expression); \
71 if (r != VK_SUCCESS) { \
73 "Vulkan: %s resulted in code %s.", \
74 __STR(__expression), \
75 blender::gpu::to_string(r)); \
93 VkSwapchainKHR vk_swapchain =
swapchains.back();
95 functions.vkDestroySwapchainKHR(vk_device, vk_swapchain,
nullptr);
100 functions.vkDestroySemaphore(vk_device, vk_semaphore,
nullptr);
125 for (
const VkExtensionProperties &extension :
extensions) {
126 if (
STREQ(extension.extensionName, extension_name)) {
135 for (
const char *extension_name : extension_names) {
143 bool enable(
const char *extension_name,
bool optional =
false)
148 "Vulkan: %s extension enabled: name=%s",
149 optional ?
"optional" :
"required",
157 "Vulkan: %s extension not available: name=%s",
158 optional ?
"optional" :
"required",
166 bool is_extension_enabled =
is_enabled(extension_name);
167 if (is_extension_enabled) {
169 &
LOG,
"Vulkan: extension disabled for compatibility reasons: name=%s", extension_name);
179 bool failure =
false;
180 for (
const char *extension_name : extension_names) {
181 failure |= !
enable(extension_name, optional);
188 for (
const char *enabled_extension_name :
enabled) {
189 if (
STREQ(enabled_extension_name, extension_name)) {
216 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
219 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES,
224 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES};
226 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES};
228 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT};
230 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR};
248 features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
249 features_11.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
274 uint32_t extensions_count;
275 VK_CHECK(volk::vkEnumerateDeviceExtensionProperties(
279 VK_CHECK(volk::vkEnumerateDeviceExtensionProperties(
295 uint32_t queue_family_count = 0;
296 volk::vkGetPhysicalDeviceQueueFamilyProperties(
299 vector<VkQueueFamilyProperties> queue_families(queue_family_count);
300 volk::vkGetPhysicalDeviceQueueFamilyProperties(
304 for (
const VkQueueFamilyProperties &queue_family : queue_families) {
308 if ((queue_family.queueFlags & VK_QUEUE_GRAPHICS_BIT) &&
309 (queue_family.queueFlags & VK_QUEUE_COMPUTE_BIT))
324 VmaAllocatorCreateInfo vma_allocator_create_info = {};
325 vma_allocator_create_info.vulkanApiVersion = VK_API_VERSION_1_1;
327 vma_allocator_create_info.device =
vk_device;
328 vma_allocator_create_info.instance = vk_instance;
329 vma_allocator_create_info.flags = VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT;
331 vma_allocator_create_info.flags |= VMA_ALLOCATOR_CREATE_EXT_MEMORY_PRIORITY_BIT;
334 vma_allocator_create_info.flags |= VMA_ALLOCATOR_CREATE_KHR_MAINTENANCE4_BIT;
336 VmaVulkanFunctions vma_vulkan_functions = {};
337 vmaImportVulkanFunctionsFromVolk(&vma_allocator_create_info, &vma_vulkan_functions);
338 vma_allocator_create_info.pVulkanFunctions = &vma_vulkan_functions;
339 vmaCreateAllocator(&vma_allocator_create_info, &
vma_allocator);
362 if (volk::vkGetInstanceProcAddr ==
nullptr) {
363 VkResult vk_result = volkInitialize();
364 if (vk_result != VK_SUCCESS) {
367 "Error initializing Vulkan loader: VkResult=%d, most likely cannot find the Vulkan "
368 "Loader provided by GPU driver/OS.",
387 uint32_t extension_count = 0;
388 VK_CHECK(volk::vkEnumerateInstanceExtensionProperties(
nullptr, &extension_count,
nullptr),
391 VK_CHECK(volk::vkEnumerateInstanceExtensionProperties(
399 VkApplicationInfo vk_application_info = {VK_STRUCTURE_TYPE_APPLICATION_INFO,
402 VK_MAKE_VERSION(1, 0, 0),
404 VK_MAKE_VERSION(1, 0, 0),
406 VkInstanceCreateInfo vk_instance_create_info = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
409 &vk_application_info,
424 VkPhysicalDevice requested_physical_device = VK_NULL_HANDLE;
425 VkPhysicalDevice fallback_physical_device = VK_NULL_HANDLE;
427 uint32_t device_count = 0;
428 volk::vkEnumeratePhysicalDevices(
vk_instance, &device_count,
nullptr);
430 vector<VkPhysicalDevice> physical_devices(device_count);
431 volk::vkEnumeratePhysicalDevices(
vk_instance, &device_count, physical_devices.data());
433 int best_device_score = -1;
437 int device_index = -1;
438 for (
const VkPhysicalDevice &physical_device : physical_devices) {
451 !device_vk.
features.features.geometryShader ||
453 !device_vk.
features.features.fragmentStoresAndAtomics ||
454 !device_vk.
features.features.imageCubeArray ||
455 !device_vk.
features.features.dualSrcBlend || !device_vk.
features.features.imageCubeArray)
460 const VkPhysicalDeviceProperties &vk_props = device_vk.
properties.properties;
463 const bool match = preferred_device.
index == device_index &&
464 (preferred_device.
vendor_id == uint(-1) ||
465 preferred_device.
vendor_id == vk_props.vendorID) &&
466 (preferred_device.
device_id == uint(-1) ||
467 preferred_device.
device_id == vk_props.deviceID);
469 requested_physical_device = physical_device;
474 int device_score = 0;
475 switch (device_vk.
properties.properties.deviceType) {
476 case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
479 case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
482 case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
485 case VK_PHYSICAL_DEVICE_TYPE_CPU:
503 if (device_score > best_device_score) {
504 fallback_physical_device = physical_device;
505 best_device_score = device_score;
509 if (requested_physical_device != VK_NULL_HANDLE) {
514 if (fallback_physical_device == VK_NULL_HANDLE) {
521 if (preferred_device.
vendor_id == uint(-1)) {
523 "Requested Vulkan GPU '%d' is unavailable or unsupported. "
524 "Run with '--gpu-device help' to list available devices.",
525 preferred_device.
index);
529 "Requested Vulkan GPU '%x/%x/%x' is unavailable or unsupported. "
530 "Run with '--gpu-device help' to list available devices.",
533 uint(preferred_device.
index));
537 if (preferred_device.
vendor_id == uint(-1)) {
539 "Requested Vulkan GPU '%d' is unavailable or unsupported. "
540 "Falling back to the saved GPU preference.",
541 preferred_device.
index);
545 "Requested Vulkan GPU '%x/%x/%x' is unavailable or unsupported. "
546 "Falling back to the saved GPU preference.",
549 uint(preferred_device.
index));
581 VK_DRIVER_ID_AMD_PROPRIETARY ||
583 VK_DRIVER_ID_AMD_OPEN_SOURCE;
584 if (is_amd_driver && is_debug) {
606 device.
properties.properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU)
609 uint32_t driver_version_major = driver_version >> 14u;
610 uint32_t driver_version_minor = driver_version & 0x3fffu;
611 if (driver_version_major < 101 ||
612 (driver_version_major == 101 && driver_version_minor < 3000))
621 float queue_priorities[] = {1.0f};
622 vector<VkDeviceQueueCreateInfo> queue_create_infos;
623 VkDeviceQueueCreateInfo graphic_queue_create_info = {};
624 graphic_queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
626 graphic_queue_create_info.queueCount = 1;
627 graphic_queue_create_info.pQueuePriorities = queue_priorities;
628 queue_create_infos.push_back(graphic_queue_create_info);
630 VkPhysicalDeviceFeatures device_features = {};
632 device_features.geometryShader = VK_TRUE;
634 device_features.vertexPipelineStoresAndAtomics =
636 device_features.multiViewport =
device.
features.features.multiViewport;
637 device_features.shaderClipDistance =
device.
features.features.shaderClipDistance;
638 device_features.fragmentStoresAndAtomics = VK_TRUE;
640 device_features.dualSrcBlend = VK_TRUE;
641 device_features.imageCubeArray = VK_TRUE;
642 device_features.multiDrawIndirect =
device.
features.features.multiDrawIndirect;
643 device_features.drawIndirectFirstInstance = VK_TRUE;
644 device_features.samplerAnisotropy =
device.
features.features.samplerAnisotropy;
647 VkDeviceCreateInfo device_create_info = {};
648 device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
649 device_create_info.queueCreateInfoCount = uint32_t(queue_create_infos.size());
650 device_create_info.pQueueCreateInfos = queue_create_infos.data();
653 device_create_info.pEnabledFeatures = &device_features;
655 std::vector<void *> feature_struct_ptr;
658 VkPhysicalDeviceTimelineSemaphoreFeatures timeline_semaphore_features = {};
659 timeline_semaphore_features.sType =
660 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
661 timeline_semaphore_features.timelineSemaphore = VK_TRUE;
662 feature_struct_ptr.push_back(&timeline_semaphore_features);
665 VkPhysicalDeviceBufferDeviceAddressFeatures buffer_device_address_features = {};
666 buffer_device_address_features.sType =
667 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
668 buffer_device_address_features.bufferDeviceAddress = VK_TRUE;
669 feature_struct_ptr.push_back(&buffer_device_address_features);
672 VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures separate_depth_stencil_layouts_features =
674 separate_depth_stencil_layouts_features.sType =
675 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
676 separate_depth_stencil_layouts_features.separateDepthStencilLayouts = VK_TRUE;
677 feature_struct_ptr.push_back(&separate_depth_stencil_layouts_features);
680 VkPhysicalDeviceProvokingVertexFeaturesEXT provoking_vertex_features = {};
682 provoking_vertex_features.sType =
683 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
684 provoking_vertex_features.provokingVertexLast = VK_TRUE;
685 feature_struct_ptr.push_back(&provoking_vertex_features);
689 VkPhysicalDeviceDynamicRenderingFeatures dynamic_rendering = {};
690 dynamic_rendering.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
691 dynamic_rendering.dynamicRendering = VK_TRUE;
692 feature_struct_ptr.push_back(&dynamic_rendering);
694 VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT
695 dynamic_rendering_unused_attachments = {};
696 dynamic_rendering_unused_attachments.sType =
697 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
698 dynamic_rendering_unused_attachments.dynamicRenderingUnusedAttachments = VK_TRUE;
700 feature_struct_ptr.push_back(&dynamic_rendering_unused_attachments);
703 VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR dynamic_rendering_local_read = {};
704 dynamic_rendering_local_read.sType =
705 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR;
706 dynamic_rendering_local_read.dynamicRenderingLocalRead = VK_TRUE;
708 feature_struct_ptr.push_back(&dynamic_rendering_local_read);
712 VkPhysicalDeviceRobustness2FeaturesEXT robustness_2_features = {
713 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT};
716 feature_struct_ptr.push_back(&robustness_2_features);
720 VkPhysicalDeviceMaintenance4FeaturesKHR maintenance_4 = {};
721 maintenance_4.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR;
722 maintenance_4.maintenance4 = VK_TRUE;
724 feature_struct_ptr.push_back(&maintenance_4);
728 VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT swapchain_maintenance_1 = {
729 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT,
nullptr, VK_TRUE};
731 feature_struct_ptr.push_back(&swapchain_maintenance_1);
736 VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR fragment_shader_barycentric = {};
737 fragment_shader_barycentric.sType =
738 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
739 fragment_shader_barycentric.fragmentShaderBarycentric = VK_TRUE;
741 feature_struct_ptr.push_back(&fragment_shader_barycentric);
745 VkPhysicalDeviceMemoryPriorityFeaturesEXT memory_priority = {
746 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT,
nullptr, VK_TRUE};
748 feature_struct_ptr.push_back(&memory_priority);
752 VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT pageable_device_local_memory = {
753 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT,
757 feature_struct_ptr.push_back(&pageable_device_local_memory);
761 VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT graphics_pipeline_library = {
762 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT,
766 feature_struct_ptr.push_back(&graphics_pipeline_library);
770 VkPhysicalDeviceLineRasterizationFeaturesKHR line_rasterization_features = {};
771 line_rasterization_features.sType =
772 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
773 line_rasterization_features.bresenhamLines = VK_TRUE;
775 feature_struct_ptr.push_back(&line_rasterization_features);
779 VkPhysicalDeviceExtendedDynamicStateFeaturesEXT extended_dynamic_state = {
780 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT,
nullptr, VK_TRUE};
782 feature_struct_ptr.push_back(&extended_dynamic_state);
786 VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT vertex_input_dynamic_state = {
787 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT,
791 feature_struct_ptr.push_back(&vertex_input_dynamic_state);
795 VkPhysicalDeviceHostImageCopyFeaturesEXT host_image_copy = {
796 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT,
nullptr, VK_TRUE};
798 feature_struct_ptr.push_back(&host_image_copy);
803 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR,
815 VkPhysicalDeviceRayQueryFeaturesKHR ray_query = {
816 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR,
nullptr, VK_TRUE};
818 feature_struct_ptr.push_back(&ray_query);
822 for (
int i = 1; i < feature_struct_ptr.size(); i++) {
823 ((VkBaseInStructure *)(feature_struct_ptr[i - 1]))->pNext =
824 (VkBaseInStructure *)(feature_struct_ptr[i]);
827 device_create_info.pNext = feature_struct_ptr[0];
829 VkResult result = volk::vkCreateDevice(
832 if (result != VK_SUCCESS) {
834# define __has_feature(x) 0
836#if (defined(__SANITIZE_ADDRESS__) || __has_feature(address_sanitizer)) && defined(__linux__)
840 "Vulkan: vkCreateDevice resulted in code %s.\n"
841 "Address Sanitizer has known incompatibilities with Nvidia Vulkan drivers on Linux,"
842 "see https://developer.blender.org/docs/handbook/tooling/asan/"
843 "#shadow-memory-issue-with-vulkan-on-nvidia-linux-drivers for more info.",
897#
if defined(WITH_GHOST_SDL)
899 SDL_Window *sdl_window,
902#elif defined(__APPLE__)
914 int contextMajorVersion,
915 int contextMinorVersion,
919#
if defined(WITH_GHOST_SDL)
921 sdl_window_(sdl_window),
924#elif defined(__APPLE__)
925 metal_layer_(metal_layer),
932 wayland_surface_(wayland_surface),
933 wayland_display_(wayland_display),
934 wayland_window_info_(wayland_window_info),
936 context_major_version_(contextMajorVersion),
937 context_minor_version_(contextMinorVersion),
938 preferred_device_(preferred_device),
940 surface_(VK_NULL_HANDLE),
941 swapchain_(VK_NULL_HANDLE),
944 use_hdr_swapchain_(false)
946 frame_data_.reserve(6);
953 if (!instance_vk.
device.has_value() || instance_vk.
device->vk_device == VK_NULL_HANDLE) {
954 if (surface_ != VK_NULL_HANDLE) {
955 volk::vkDestroySurfaceKHR(instance_vk.
vk_instance, surface_,
nullptr);
956 surface_ = VK_NULL_HANDLE;
964 for (VkFence fence : fence_pile_) {
970 if (surface_ != VK_NULL_HANDLE) {
971 volk::vkDestroySurfaceKHR(instance_vk.
vk_instance, surface_,
nullptr);
972 surface_ = VK_NULL_HANDLE;
975 if (device_vk.
users > 0) {
978 if (device_vk.
users == 0) {
986 if (acquired_swapchain_image_index_.has_value()) {
992 VkDevice vk_device = device_vk.
vk_device;
1007 render_frame_ = (render_frame_ + 1) % frame_data_.size();
1008 GHOST_Frame &submission_frame_data = frame_data_[render_frame_];
1017 this->destroySwapchainPresentFences(swapchain);
1021 const bool use_hdr_swapchain = hdr_info_ &&
1022 (hdr_info_->wide_gamut_enabled || hdr_info_->hdr_enabled) &&
1024 if (use_hdr_swapchain != use_hdr_swapchain_) {
1026 recreateSwapchain(use_hdr_swapchain);
1029#ifdef WITH_GHOST_WAYLAND
1033 if (wayland_window_info_) {
1034 const bool recreate_swapchain =
1035 ((wayland_window_info_->size[0] !=
1036 std::max(render_extent_.width, render_extent_min_.width)) ||
1037 (wayland_window_info_->size[1] !=
1038 std::max(render_extent_.height, render_extent_min_.height)));
1040 if (recreate_swapchain) {
1042 recreateSwapchain(use_hdr_swapchain);
1049 if (swapchain_ == VK_NULL_HANDLE) {
1050 recreateSwapchain(use_hdr_swapchain);
1054 uint32_t image_index = 0;
1055 if (swapchain_ != VK_NULL_HANDLE) {
1058 VkResult acquire_result = VK_ERROR_OUT_OF_DATE_KHR;
1059 while (swapchain_ != VK_NULL_HANDLE &&
1060 (
ELEM(acquire_result, VK_ERROR_OUT_OF_DATE_KHR, VK_SUBOPTIMAL_KHR)))
1062 acquire_result = device_vk.
functions.vkAcquireNextImageKHR(
1069 if (
ELEM(acquire_result, VK_ERROR_OUT_OF_DATE_KHR, VK_SUBOPTIMAL_KHR)) {
1070 recreateSwapchain(use_hdr_swapchain);
1085 if (swap_buffer_acquired_callback_) {
1086 swap_buffer_acquired_callback_();
1089 if (swapchain_ == VK_NULL_HANDLE) {
1090 CLOG_TRACE(&
LOG,
"Swap-chain unavailable (minimized window).");
1095 "Acquired swap-chain image (render_frame=%" PRIu64 ", image_index=%u)",
1098 acquired_swapchain_image_index_ = image_index;
1102VkFence GHOST_ContextVK::getFence()
1104 if (!fence_pile_.empty()) {
1105 VkFence fence = fence_pile_.back();
1106 fence_pile_.pop_back();
1110 VkFence fence = VK_NULL_HANDLE;
1111 const VkFenceCreateInfo fence_create_info = {VK_STRUCTURE_TYPE_FENCE_CREATE_INFO};
1112 device_vk.
functions.vkCreateFence(device_vk.
vk_device, &fence_create_info,
nullptr, &fence);
1116void GHOST_ContextVK::setPresentFence(VkSwapchainKHR swapchain, VkFence present_fence)
1118 if (present_fence == VK_NULL_HANDLE) {
1121 present_fences_[swapchain].push_back(present_fence);
1124 for (std::pair<
const VkSwapchainKHR, std::vector<VkFence>> &item : present_fences_) {
1125 std::vector<VkFence>::iterator end = item.second.end();
1126 std::vector<VkFence>::iterator it = std::remove_if(
1127 item.second.begin(), item.second.end(), [&](
const VkFence fence) {
1128 if (device_vk.functions.vkGetFenceStatus(device_vk.vk_device, fence) == VK_NOT_READY) {
1132 fence_pile_.push_back(fence);
1135 item.second.erase(it, end);
1143 if (swapchain_ == VK_NULL_HANDLE) {
1144 GHOST_VulkanSwapChainData swap_chain_data = {};
1145 if (swap_buffer_draw_callback_) {
1146 swap_buffer_draw_callback_(&swap_chain_data,
true);
1151 if (!acquired_swapchain_image_index_.has_value()) {
1156 VkDevice vk_device = device_vk.
vk_device;
1158 uint32_t image_index = acquired_swapchain_image_index_.value();
1160 GHOST_Frame &submission_frame_data = frame_data_[render_frame_];
1161 const bool use_hdr_swapchain = hdr_info_ &&
1162 (hdr_info_->wide_gamut_enabled || hdr_info_->hdr_enabled) &&
1165 GHOST_VulkanSwapChainData swap_chain_data;
1166 swap_chain_data.image = swapchain_image.
vk_image;
1167 swap_chain_data.surface_format = surface_format_;
1168 swap_chain_data.extent = render_extent_;
1172 swap_chain_data.sdr_scale = (hdr_info_) ? hdr_info_->sdr_white_level : 1.0f;
1175 if (swap_buffer_draw_callback_) {
1176 swap_buffer_draw_callback_(&swap_chain_data,
true);
1179 VkPresentInfoKHR present_info = {};
1180 present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
1181 present_info.waitSemaphoreCount = 1;
1183 present_info.swapchainCount = 1;
1184 present_info.pSwapchains = &swapchain_;
1185 present_info.pImageIndices = &image_index;
1186 present_info.pResults =
nullptr;
1188 VkResult present_result = VK_SUCCESS;
1191 VkSwapchainPresentFenceInfoEXT fence_info{VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT};
1192 VkFence present_fence = VK_NULL_HANDLE;
1194 present_fence = this->getFence();
1196 fence_info.swapchainCount = 1;
1197 fence_info.pFences = &present_fence;
1199 present_info.pNext = &fence_info;
1202 this->setPresentFence(swapchain_, present_fence);
1204 acquired_swapchain_image_index_.reset();
1206 if (
ELEM(present_result, VK_ERROR_OUT_OF_DATE_KHR, VK_SUBOPTIMAL_KHR)) {
1207 recreateSwapchain(use_hdr_swapchain);
1210 if (present_result != VK_SUCCESS) {
1212 "Vulkan: failed to present swap-chain image : %s",
1221 GHOST_VulkanSwapChainData *r_swap_chain_data)
1223 r_swap_chain_data->image = VK_NULL_HANDLE;
1224 r_swap_chain_data->surface_format = surface_format_;
1225 r_swap_chain_data->extent = render_extent_;
1226 r_swap_chain_data->sdr_scale = (hdr_info_) ? hdr_info_->sdr_white_level : 1.0f;
1261 std::function<
void(
const GHOST_VulkanSwapChainData *,
bool)> swap_buffer_draw_callback,
1262 std::function<
void(
void)> swap_buffer_acquired_callback,
1263 std::function<
void(GHOST_VulkanOpenXRData *)> openxr_acquire_framebuffer_image_callback,
1264 std::function<
void(GHOST_VulkanOpenXRData *)> openxr_release_framebuffer_image_callback)
1266 swap_buffer_draw_callback_ = swap_buffer_draw_callback;
1267 swap_buffer_acquired_callback_ = swap_buffer_acquired_callback;
1268 openxr_acquire_framebuffer_image_callback_ = openxr_acquire_framebuffer_image_callback;
1269 openxr_release_framebuffer_image_callback_ = openxr_release_framebuffer_image_callback;
1290 case VK_FORMAT_B8G8R8A8_UNORM:
1291 return STRINGIFY(VK_FORMAT_B8G8R8A8_UNORM);
1292 case VK_FORMAT_R16G16B16A16_SFLOAT:
1293 return STRINGIFY(VK_FORMAT_R16G16B16A16_SFLOAT);
1301 switch (color_space) {
1302 case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR:
1303 return STRINGIFY(VK_COLOR_SPACE_SRGB_NONLINEAR_KHR);
1304 case VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT:
1305 return STRINGIFY(VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT);
1306 case VK_COLOR_SPACE_PASS_THROUGH_EXT:
1307 return STRINGIFY(VK_COLOR_SPACE_PASS_THROUGH_EXT);
1308 case VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT:
1309 return STRINGIFY(VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT);
1310 case VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT:
1311 return STRINGIFY(VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT);
1312 case VK_COLOR_SPACE_BT709_LINEAR_EXT:
1313 return STRINGIFY(VK_COLOR_SPACE_BT709_LINEAR_EXT);
1314 case VK_COLOR_SPACE_BT709_NONLINEAR_EXT:
1315 return STRINGIFY(VK_COLOR_SPACE_BT709_NONLINEAR_EXT);
1316 case VK_COLOR_SPACE_BT2020_LINEAR_EXT:
1317 return STRINGIFY(VK_COLOR_SPACE_BT2020_LINEAR_EXT);
1318 case VK_COLOR_SPACE_HDR10_ST2084_EXT:
1319 return STRINGIFY(VK_COLOR_SPACE_HDR10_ST2084_EXT);
1320 case VK_COLOR_SPACE_DISPLAY_NATIVE_AMD:
1321 return STRINGIFY(VK_COLOR_SPACE_DISPLAY_NATIVE_AMD);
1329 switch (present_mode) {
1330 case VK_PRESENT_MODE_FIFO_KHR:
1331 return STRINGIFY(VK_PRESENT_MODE_FIFO_KHR);
1332 case VK_PRESENT_MODE_MAILBOX_KHR:
1333 return STRINGIFY(VK_PRESENT_MODE_MAILBOX_KHR);
1334 case VK_PRESENT_MODE_IMMEDIATE_KHR:
1335 return STRINGIFY(VK_PRESENT_MODE_IMMEDIATE_KHR);
1336 case VK_PRESENT_MODE_FIFO_RELAXED_KHR:
1337 return STRINGIFY(VK_PRESENT_MODE_FIFO_RELAXED_KHR);
1344 VkPhysicalDevice device,
1345 VkSurfaceKHR surface,
1346 VkPresentModeKHR *r_presentMode)
1348 uint32_t present_count;
1349 volk::vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &present_count,
nullptr);
1351 volk::vkGetPhysicalDeviceSurfacePresentModesKHR(
1352 device, surface, &present_count, presents.data());
1357 for (
const VkPresentModeKHR present_mode : presents) {
1358 if (present_mode == VK_PRESENT_MODE_IMMEDIATE_KHR) {
1359 *r_presentMode = present_mode;
1364 "Vulkan: VSync off was requested via --gpu-vsync, "
1365 "but VK_PRESENT_MODE_IMMEDIATE_KHR is not supported.");
1374 for (
const VkPresentModeKHR present_mode : presents) {
1375 if (present_mode == VK_PRESENT_MODE_MAILBOX_KHR) {
1376 *r_presentMode = present_mode;
1384 *r_presentMode = VK_PRESENT_MODE_FIFO_KHR;
1394 const VkSurfaceKHR surface,
1395 bool use_hdr_swapchain,
1396 VkSurfaceFormatKHR &r_surfaceFormat)
1398 uint32_t format_count;
1399 volk::vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, surface, &format_count,
nullptr);
1401 volk::vkGetPhysicalDeviceSurfaceFormatsKHR(
1402 physical_device, surface, &format_count, formats.data());
1405#if defined(_WIN32) || defined(__APPLE__)
1406 {VK_FORMAT_R16G16B16A16_SFLOAT, VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT},
1408 {VK_FORMAT_R16G16B16A16_SFLOAT, VK_COLOR_SPACE_PASS_THROUGH_EXT},
1411 {VK_FORMAT_B8G8R8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}}};
1413 for (
const VkSurfaceFormatKHR &config : selection_order) {
1414 if (!use_hdr_swapchain && config.format == VK_FORMAT_R16G16B16A16_SFLOAT) {
1418 for (
const VkSurfaceFormatKHR &format : formats) {
1419 if (format.format == config.format && format.colorSpace == config.colorSpace) {
1420 r_surfaceFormat = format;
1434 const VkSemaphoreCreateInfo vk_semaphore_create_info = {
1435 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
nullptr, 0};
1436 const VkFenceCreateInfo vk_fence_create_info = {
1437 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
nullptr, VK_FENCE_CREATE_SIGNALED_BIT};
1438 for (GHOST_SwapchainImage &swapchain_image : swapchain_images_) {
1440 if (swapchain_image.present_semaphore == VK_NULL_HANDLE) {
1442 device, &vk_semaphore_create_info,
nullptr, &swapchain_image.present_semaphore),
1448 GHOST_Frame &frame_data = frame_data_[
index];
1465GHOST_TSuccess GHOST_ContextVK::recreateSwapchain(
bool use_hdr_swapchain)
1468 GHOST_DeviceVK &device_vk = instance_vk.
device.value();
1470 surface_format_ = {};
1477 VkPresentModeKHR present_mode;
1483 VkSurfacePresentScalingCapabilitiesEXT vk_surface_present_scaling_capabilities = {
1484 VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT,
1486 VkSurfaceCapabilities2KHR vk_surface_capabilities = {
1487 VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR,
1488 &vk_surface_present_scaling_capabilities,
1490 VkSurfacePresentModeEXT vk_surface_present_mode = {
1491 VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT,
nullptr, present_mode};
1492 VkPhysicalDeviceSurfaceInfo2KHR vk_physical_device_surface_info = {
1493 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, &vk_surface_present_mode, surface_};
1494 VkSurfaceCapabilitiesKHR capabilities = {};
1498 &vk_physical_device_surface_info,
1499 &vk_surface_capabilities),
1501 capabilities = vk_surface_capabilities.surfaceCapabilities;
1504 VK_CHECK(volk::vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
1509 use_hdr_swapchain_ = use_hdr_swapchain;
1510 render_extent_ = capabilities.currentExtent;
1511 render_extent_min_ = capabilities.minImageExtent;
1518#ifdef WITH_GHOST_WAYLAND
1520 if (wayland_window_info_) {
1521 width = wayland_window_info_->size[0];
1522 height = wayland_window_info_->size[1];
1526 if (width == 0 || height == 0) {
1531 render_extent_.width = width;
1532 render_extent_.height = height;
1534 if (capabilities.minImageExtent.width > render_extent_.width) {
1535 render_extent_.width = capabilities.minImageExtent.width;
1537 if (capabilities.minImageExtent.height > render_extent_.height) {
1538 render_extent_.height = capabilities.minImageExtent.height;
1543 if (vk_surface_present_scaling_capabilities.minScaledImageExtent.width > render_extent_.width)
1545 render_extent_.width = vk_surface_present_scaling_capabilities.minScaledImageExtent.width;
1547 if (vk_surface_present_scaling_capabilities.minScaledImageExtent.height >
1548 render_extent_.height)
1550 render_extent_.height = vk_surface_present_scaling_capabilities.minScaledImageExtent.height;
1555 GHOST_FrameDiscard &discard_pile = frame_data_[render_frame_].discard_pile;
1556 for (GHOST_SwapchainImage &swapchain_image : swapchain_images_) {
1557 swapchain_image.vk_image = VK_NULL_HANDLE;
1558 if (swapchain_image.present_semaphore != VK_NULL_HANDLE) {
1559 discard_pile.
semaphores.push_back(swapchain_image.present_semaphore);
1560 swapchain_image.present_semaphore = VK_NULL_HANDLE;
1569 if (render_extent_.width == 0 || render_extent_.height == 0) {
1571 discard_pile.
swapchains.push_back(swapchain_);
1572 swapchain_ = VK_NULL_HANDLE;
1580 uint32_t image_count_requested = present_mode == VK_PRESENT_MODE_MAILBOX_KHR ? 3 : 2;
1582 if (capabilities.minImageCount != 0 && image_count_requested < capabilities.minImageCount) {
1583 image_count_requested = capabilities.minImageCount;
1585 if (capabilities.maxImageCount != 0 && image_count_requested > capabilities.maxImageCount) {
1586 image_count_requested = capabilities.maxImageCount;
1589 VkSwapchainKHR old_swapchain = swapchain_;
1594 VkPresentScalingFlagBitsEXT vk_present_scaling = old_swapchain == VK_NULL_HANDLE ?
1595 VK_PRESENT_SCALING_STRETCH_BIT_EXT :
1596 VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT;
1598 VkSwapchainPresentModesCreateInfoEXT vk_swapchain_present_modes = {
1599 VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT,
nullptr, 1, &present_mode};
1600 VkSwapchainPresentScalingCreateInfoEXT vk_swapchain_present_scaling = {
1601 VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT,
1602 &vk_swapchain_present_modes,
1603 vk_surface_present_scaling_capabilities.supportedPresentScaling & vk_present_scaling,
1604 vk_surface_present_scaling_capabilities.supportedPresentGravityX &
1605 VK_PRESENT_GRAVITY_MIN_BIT_EXT,
1606 vk_surface_present_scaling_capabilities.supportedPresentGravityY &
1607 VK_PRESENT_GRAVITY_MAX_BIT_EXT,
1610 VkSwapchainCreateInfoKHR create_info = {};
1611 create_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
1613 create_info.pNext = &vk_swapchain_present_scaling;
1615 create_info.surface = surface_;
1616 create_info.minImageCount = image_count_requested;
1617 create_info.imageFormat = surface_format_.format;
1618 create_info.imageColorSpace = surface_format_.colorSpace;
1619 create_info.imageExtent = render_extent_;
1620 create_info.imageArrayLayers = 1;
1621 create_info.imageUsage = VK_IMAGE_USAGE_TRANSFER_DST_BIT |
1622 (use_hdr_swapchain ? VK_IMAGE_USAGE_STORAGE_BIT : 0);
1623 create_info.preTransform = capabilities.currentTransform;
1628 (capabilities.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR))
1630 create_info.compositeAlpha = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR;
1633 create_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
1636 create_info.presentMode = present_mode;
1637 create_info.clipped = VK_TRUE;
1638 create_info.oldSwapchain = old_swapchain;
1639 create_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
1640 create_info.queueFamilyIndexCount = 0;
1641 create_info.pQueueFamilyIndices =
nullptr;
1644 device_vk.
vk_device, &create_info,
nullptr, &swapchain_),
1649 device_vk.
functions.vkGetSwapchainImagesKHR(
1650 device_vk.
vk_device, swapchain_, &actual_image_count,
nullptr);
1654 if (actual_image_count > frame_data_.size()) {
1655 CLOG_TRACE(&
LOG,
"Vulkan: Increasing frame data to %u frames", actual_image_count);
1656 assert(actual_image_count <= frame_data_.capacity());
1657 frame_data_.resize(actual_image_count);
1659 swapchain_images_.resize(actual_image_count);
1660 std::vector<VkImage> swapchain_images(actual_image_count);
1661 device_vk.
functions.vkGetSwapchainImagesKHR(
1662 device_vk.
vk_device, swapchain_, &actual_image_count, swapchain_images.data());
1664 swapchain_images_[
index].vk_image = swapchain_images[
index];
1667 "Vulkan: recreating swapchain: width=%u, height=%u, format=%s, colorSpace=%s, "
1668 "present_mode=%s, image_count_requested=%u, image_count_acquired=%u, "
1670 render_extent_.width,
1671 render_extent_.height,
1675 image_count_requested,
1682 for (GHOST_Frame &frame : frame_data_) {
1683 if (frame.acquire_semaphore != VK_NULL_HANDLE) {
1684 discard_pile.
semaphores.push_back(frame.acquire_semaphore);
1686 frame.acquire_semaphore = VK_NULL_HANDLE;
1688 if (old_swapchain) {
1689 discard_pile.
swapchains.push_back(old_swapchain);
1691 initializeFrameData();
1693 image_count_ = actual_image_count;
1698void GHOST_ContextVK::destroySwapchainPresentFences(VkSwapchainKHR swapchain)
1701 const std::vector<VkFence> &fences = present_fences_[swapchain];
1702 if (!fences.empty()) {
1705 for (VkFence fence : fences) {
1709 present_fences_.erase(swapchain);
1716 if (swapchain_ != VK_NULL_HANDLE) {
1717 this->destroySwapchainPresentFences(swapchain_);
1721 for (GHOST_SwapchainImage &swapchain_image : swapchain_images_) {
1724 swapchain_images_.clear();
1725 for (GHOST_Frame &frame_data : frame_data_) {
1727 this->destroySwapchainPresentFences(swapchain);
1731 frame_data_.clear();
1736std::vector<const char *> GHOST_ContextVK::getPlatformSpecificSurfaceExtensions()
const
1738 std::vector<const char *> extensions;
1739#if defined(WITH_GHOST_SDL)
1741 Uint32 sdl_extension_count = 0;
1742 const char *
const *sdl_extensions = SDL_Vulkan_GetInstanceExtensions(&sdl_extension_count);
1743 for (Uint32 i = 0; i < sdl_extension_count; i++) {
1744 extensions.push_back(sdl_extensions[i]);
1746#elif defined(_WIN32)
1747 extensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
1748#elif defined(__APPLE__)
1749 extensions.push_back(VK_EXT_METAL_SURFACE_EXTENSION_NAME);
1751 switch (platform_) {
1752# ifdef WITH_GHOST_X11
1753 case GHOST_kVulkanPlatformX11:
1754 extensions.push_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
1757# ifdef WITH_GHOST_WAYLAND
1758 case GHOST_kVulkanPlatformWayland:
1759 extensions.push_back(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);
1771 bool use_vk_ext_swapchain_colorspace =
false;
1772#if defined(WITH_GHOST_SDL)
1773 const bool use_window_surface = (sdl_window_ !=
nullptr);
1774#elif defined(_WIN32)
1775 const bool use_window_surface = (hwnd_ !=
nullptr);
1776#elif defined(__APPLE__)
1777 const bool use_window_surface = (metal_layer_ !=
nullptr);
1779 bool use_window_surface =
false;
1780 switch (platform_) {
1781# ifdef WITH_GHOST_X11
1782 case GHOST_kVulkanPlatformX11:
1783 use_window_surface = (display_ !=
nullptr) && (window_ != (
Window)
nullptr);
1786# ifdef WITH_GHOST_WAYLAND
1787 case GHOST_kVulkanPlatformWayland:
1788 use_window_surface = (wayland_display_ !=
nullptr) && (wayland_surface_ !=
nullptr);
1792 use_window_surface =
false;
1805 instance_vk.
extensions.
enable(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
1813#ifdef WITH_XR_OPENXR
1815 instance_vk.
extensions.
enable(VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME);
1816 instance_vk.
extensions.
enable(VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME);
1817 instance_vk.
extensions.
enable(VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME);
1820 instance_vk.
extensions.
enable(VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME,
true);
1826 if (use_window_surface) {
1827 const std::vector<const char *> surface_extensions = getPlatformSpecificSurfaceExtensions();
1830 for (
const char *extension : surface_extensions) {
1836 const bool use_vk_ext_swapchain_maintenance1 =
1837#ifdef WITH_GHOST_X11
1838 platform_ != GHOST_kVulkanPlatformX11 &&
1842 if (use_vk_ext_swapchain_maintenance1) {
1843 instance_vk.
extensions.
enable(VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME);
1844 instance_vk.
extensions.
enable(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME);
1845 optional_device_extensions.
append(VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME);
1849 VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME,
true);
1851 required_device_extensions.
append(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
1855 VK_MAKE_VERSION(context_major_version_, context_minor_version_, 0)))
1865 if (use_window_surface) {
1866#if defined(WITH_GHOST_SDL)
1867 if (!SDL_Vulkan_CreateSurface(sdl_window_, instance_vk.
vk_instance,
nullptr, &surface_)) {
1868 CLOG_ERROR(&
LOG,
"SDL_Vulkan_CreateSurface failed: %s", SDL_GetError());
1871#elif defined(_WIN32)
1872 VkWin32SurfaceCreateInfoKHR surface_create_info = {};
1873 surface_create_info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
1874 surface_create_info.hinstance = GetModuleHandle(
nullptr);
1875 surface_create_info.hwnd = hwnd_;
1876 VK_CHECK(volk::vkCreateWin32SurfaceKHR(
1877 instance_vk.
vk_instance, &surface_create_info,
nullptr, &surface_),
1879#elif defined(__APPLE__)
1880 VkMetalSurfaceCreateInfoEXT info = {};
1881 info.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
1882 info.pNext =
nullptr;
1884 info.pLayer =
static_cast<CAMetalLayer *
>(metal_layer_);
1885 VK_CHECK(volk::vkCreateMetalSurfaceEXT(instance_vk.
vk_instance, &info,
nullptr, &surface_),
1888 switch (platform_) {
1889# ifdef WITH_GHOST_X11
1890 case GHOST_kVulkanPlatformX11: {
1891 VkXlibSurfaceCreateInfoKHR surface_create_info = {};
1892 surface_create_info.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
1893 surface_create_info.dpy = display_;
1894 surface_create_info.window = window_;
1895 VK_CHECK(volk::vkCreateXlibSurfaceKHR(
1896 instance_vk.
vk_instance, &surface_create_info,
nullptr, &surface_),
1901# ifdef WITH_GHOST_WAYLAND
1902 case GHOST_kVulkanPlatformWayland: {
1903 VkWaylandSurfaceCreateInfoKHR surface_create_info = {};
1904 surface_create_info.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
1905 surface_create_info.display = wayland_display_;
1906 surface_create_info.surface = wayland_surface_;
1907 VK_CHECK(vkCreateWaylandSurfaceKHR(
1908 instance_vk.
vk_instance, &surface_create_info,
nullptr, &surface_),
1914 surface_ = VK_NULL_HANDLE;
1926 optional_device_extensions.
append(VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME);
1927#elif defined(__APPLE__)
1929 optional_device_extensions.
append(VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME);
1932 optional_device_extensions.
append(VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME);
1933 required_device_extensions.
append(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME);
1934 required_device_extensions.
append(VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME);
1935 required_device_extensions.
append(VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME);
1936 required_device_extensions.
append(VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME);
1937 required_device_extensions.
append(VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME);
1938 required_device_extensions.
append(VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME);
1939 optional_device_extensions.
append(VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME);
1940 optional_device_extensions.
append(VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME);
1941 optional_device_extensions.
append(VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME);
1942 optional_device_extensions.
append(VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME);
1943 optional_device_extensions.
append(VK_KHR_MAINTENANCE_4_EXTENSION_NAME);
1944 optional_device_extensions.
append(VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME);
1945 optional_device_extensions.
append(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME);
1946 optional_device_extensions.
append(VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME);
1947 optional_device_extensions.
append(VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME);
1948 optional_device_extensions.
append(VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME);
1949 optional_device_extensions.
append(VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME);
1950 optional_device_extensions.
append(VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME);
1951 optional_device_extensions.
append(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME);
1954 optional_device_extensions.
append(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
1956 optional_device_extensions.
append(VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
1957 optional_device_extensions.
append(VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME);
1958 optional_device_extensions.
append(VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME);
1961 optional_device_extensions.
append(VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME);
1964#ifdef WITH_XR_OPENXR
1965 optional_device_extensions.
extend({
1967 VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME,
1968 VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME,
1970 VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME,
1971# elif defined(__APPLE__)
1973 VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME,
1974 VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME,
1977 VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME,
1978 VK_KHR_BIND_MEMORY_2_EXTENSION_NAME,
1979 VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME,
1980 VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME,
1981 VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME,
1982 VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME,
1983 VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME,
1984 VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME,
1985 VK_KHR_MULTIVIEW_EXTENSION_NAME,
1986 VK_KHR_MAINTENANCE_1_EXTENSION_NAME,
1987 VK_KHR_MAINTENANCE_2_EXTENSION_NAME,
1990 VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME,
1991 VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME,
1994 VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME,
1997 VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME,
2000 VK_EXT_DEBUG_MARKER_EXTENSION_NAME});
2003 optional_device_extensions.
append(VK_KHR_RAY_QUERY_EXTENSION_NAME);
2004 optional_device_extensions.
append(VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME);
2005 optional_device_extensions.
append(VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME);
2006 optional_device_extensions.
append(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME);
2007 optional_device_extensions.
append(VK_KHR_SPIRV_1_4_EXTENSION_NAME);
2008 optional_device_extensions.
append(VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME);
2014 if (!instance_vk.
create_device(use_vk_ext_swapchain_colorspace,
2017 required_device_extensions,
2018 optional_device_extensions))
2027 render_extent_ = {0, 0};
2028 render_extent_min_ = {0, 0};
2040#ifdef WITH_GHOST_WAYLAND
2056 uint32_t major_version = (driver_version >> 22) & 0x3ff;
2061 if (major_version < 595) {
#define CLOG_ERROR(clg_ref,...)
#define CLOG_DEBUG(clg_ref,...)
#define CLOG_WARN(clg_ref,...)
#define CLOG_AT_LEVEL(clg_ref, verbose_level,...)
#define CLOG_TRACE(clg_ref,...)
static bool selectSurfaceFormat(const VkPhysicalDevice physical_device, const VkSurfaceKHR surface, bool use_hdr_swapchain, VkSurfaceFormatKHR &r_surfaceFormat)
static std::optional< GHOST_InstanceVK > vulkan_instance
#define VK_CHECK(__expression, fail_value)
static const char * to_string_vk_present_mode(VkPresentModeKHR present_mode)
static const char * to_string_vk_color_space(VkColorSpaceKHR color_space)
static const char * to_string_vk_format(VkFormat format)
static GHOST_TSuccess selectPresentMode(const GHOST_TVSyncModes vsync, VkPhysicalDevice device, VkSurfaceKHR surface, VkPresentModeKHR *r_presentMode)
GHOST_TVulkanPlatformType
@ GHOST_kVulkanPlatformHeadless
unsigned long long int uint64_t
GHOST_TSuccess swapBufferRelease() override
GHOST_TSuccess activateDrawingContext() override
GHOST_TSuccess getVulkanSwapChainFormat(GHOST_VulkanSwapChainData *r_swap_chain_data) override
GHOST_ContextVK(const GHOST_ContextParams &context_params, GHOST_TVulkanPlatformType platform, Window window, Display *display, wl_surface *wayland_surface, wl_display *wayland_display, const GHOST_ContextVK_WindowInfo *wayland_window_info, int contextMajorVersion, int contextMinorVersion, const GHOST_GPUDevice &preferred_device, const GHOST_WindowHDRInfo *hdr_info_=nullptr)
GHOST_TSuccess initializeDrawingContext() override
GHOST_TSuccess getVulkanHandles(GHOST_VulkanHandles &r_handles) override
static bool is_instance_extension_enabled(blender::StringRefNull extension_name)
Is the given extension name enabled on instance level?
GHOST_TSuccess releaseDrawingContext() override
GHOST_TSuccess swapBufferAcquire() override
GHOST_TSuccess releaseNativeHandles() override
~GHOST_ContextVK() override
GHOST_TSuccess setVulkanSwapBuffersCallbacks(std::function< void(const GHOST_VulkanSwapChainData *, bool)> swap_buffer_draw_callback, std::function< void(void)> swap_buffer_acquired_callback, std::function< void(GHOST_VulkanOpenXRData *)> openxr_acquire_framebuffer_image_callback, std::function< void(GHOST_VulkanOpenXRData *)> openxr_release_framebuffer_image_callback) override
static bool is_device_extension_enabled(blender::StringRefNull extension_name)
Is the given extension name enabled on device level?
GHOST_Context(const GHOST_ContextParams &context_params)
static GHOST_Context * active_context_
virtual GHOST_TVSyncModes getVSync()
GHOST_ContextParams context_params_
VkPhysicalDevice vk_physical_device
VkPhysicalDeviceDriverProperties device_driver_properties
VmaAllocator vma_allocator
void init_generic_queue_family()
VkPhysicalDeviceTimelineSemaphoreFeatures features_timeline_semaphore
VkPhysicalDeviceRobustness2FeaturesEXT features_robustness2
bool use_vk_ext_swapchain_maintenance_1
VolkDeviceTable functions
void init_memory_allocator(VkInstance vk_instance)
VkPhysicalDeviceFeatures2 features
uint32_t generic_queue_family
VkPhysicalDeviceAccelerationStructureFeaturesKHR features_acceleration_structure
VkPhysicalDeviceProperties2 properties
GHOST_ExtensionsVK extensions
void init_generic_queue()
VkPhysicalDeviceBufferDeviceAddressFeatures features_buffer_device_address
bool use_vk_ext_swapchain_colorspace
VkPhysicalDeviceVulkan11Features features_11
GHOST_DeviceVK(VkPhysicalDevice vk_physical_device, const bool use_vk_ext_swapchain_colorspace)
constexpr const char * c_str() const
void append(const T &value)
void remove(const int64_t index)
void resize(const int64_t new_size)
int64_t first_index_of(const T &value) const
void extend(Span< T > array)
#define assert(assertion)
#define acceleration_structure(slot)
#define VK_FORMAT_R8G8B8A8_UNORM
const char * to_string(ShaderStage stage)
bool GPU_vulkan_is_supported_driver(VkPhysicalDevice vk_physical_device)
blender::Vector< VkExtensionProperties > extensions
bool is_supported(const char *extension_name) const
bool is_enabled(const char *extension_name) const
bool enable(const char *extension_name, bool optional=false)
blender::Vector< const char * > enabled
bool disable(const char *extension_name)
bool enable(const blender::Span< const char * > &extension_names, bool optional=false)
bool is_supported(blender::Span< const char * > extension_names)
void destroy(VkDevice vk_device, const volk::VolkDeviceTable &functions)
std::vector< VkSwapchainKHR > swapchains
std::vector< VkSemaphore > semaphores
VkSemaphore acquire_semaphore
GHOST_FrameDiscard discard_pile
void destroy(VkDevice vk_device, const volk::VolkDeviceTable &functions)
bool fail_on_invalid_override
VkPhysicalDevice vk_physical_device
std::optional< GHOST_DeviceVK > device
bool select_physical_device(const GHOST_GPUDevice &preferred_device, const blender::Span< const char * > required_extensions)
GHOST_ExtensionsVK extensions
bool create_instance(uint32_t vulkan_api_version)
bool create_device(const bool use_vk_ext_swapchain_maintenance1, const bool is_debug, const bool no_hw_rt, blender::Span< const char * > required_device_extensions, blender::Span< const char * > optional_device_extensions)
void destroy(VkDevice vk_device, const volk::VolkDeviceTable &functions)
VkSemaphore present_semaphore