22# include <vulkan/vulkan_win32.h>
43 if (vk_buffer_ != VK_NULL_HANDLE) {
44 vmaUnmapMemory(vma_allocator_, vk_buffer_allocation_);
45 vmaDestroyBuffer(vma_allocator_, vk_buffer_, vk_buffer_allocation_);
46 vk_buffer_ = VK_NULL_HANDLE;
47 vk_buffer_allocation_ = VK_NULL_HANDLE;
50 for (ImportedMemory &imported_memory : imported_memory_) {
51 functions.vkDestroyImage(vk_device_, imported_memory.vk_image_xr,
nullptr);
52 functions.vkFreeMemory(vk_device_, imported_memory.vk_device_memory_xr,
nullptr);
54 imported_memory_.clear();
57 if (vma_allocator_ != VK_NULL_HANDLE) {
58 vmaDestroyAllocator(vma_allocator_);
59 vma_allocator_ = VK_NULL_HANDLE;
63 if (vk_command_buffer_ != VK_NULL_HANDLE) {
64 functions.vkFreeCommandBuffers(vk_device_, vk_command_pool_, 1, &vk_command_buffer_);
65 vk_command_buffer_ = VK_NULL_HANDLE;
69 if (vk_command_pool_ != VK_NULL_HANDLE) {
70 functions.vkDestroyCommandPool(vk_device_, vk_command_pool_,
nullptr);
71 vk_command_pool_ = VK_NULL_HANDLE;
74 vk_queue_ = VK_NULL_HANDLE;
77 if (vk_device_ != VK_NULL_HANDLE) {
78 functions.vkDestroyDevice(vk_device_,
nullptr);
79 vk_device_ = VK_NULL_HANDLE;
83 if (vk_instance_ != VK_NULL_HANDLE) {
84 vkDestroyInstance(vk_instance_,
nullptr);
85 vk_instance_ = VK_NULL_HANDLE;
93#define LOAD_FUNCTION(fn_ptr, name) \
94 XR_SUCCEEDED(xrGetInstanceProcAddr(instance, #name, (PFN_xrVoidFunction *)&fn_ptr))
96 extensions_.vulkan_enable =
LOAD_FUNCTION(functions_.xrGetVulkanInstanceExtensionsKHR,
97 xrGetVulkanInstanceExtensionsKHR) &&
99 xrGetVulkanDeviceExtensionsKHR) &&
101 xrGetVulkanGraphicsDeviceKHR) &&
103 xrGetVulkanGraphicsRequirementsKHR);
104 extensions_.vulkan_enable2 =
105 LOAD_FUNCTION(functions_.xrGetVulkanGraphicsRequirements2KHR,
106 xrGetVulkanGraphicsRequirements2KHR) &&
107 LOAD_FUNCTION(functions_.xrGetVulkanGraphicsDevice2KHR, xrGetVulkanGraphicsDevice2KHR) &&
108 LOAD_FUNCTION(functions_.xrCreateVulkanInstanceKHR, xrCreateVulkanInstanceKHR) &&
109 LOAD_FUNCTION(functions_.xrCreateVulkanDeviceKHR, xrCreateVulkanDeviceKHR);
114 "XR/Vulkan graphics extensions:\n"
115 " - [%c] XR_KHR_vulkan_enable\n"
116 " - [%c] XR_KHR_vulkan_enable2",
117 extensions_.vulkan_enable ?
'X' :
' ',
118 extensions_.vulkan_enable2 ?
'X' :
' ');
119 return extensions_.vulkan_enable || extensions_.vulkan_enable2;
124 XrSystemId system_id,
125 std::string *r_requirement_info)
const
127 std::ostringstream strstream;
130 const XrVersion vk_version = XR_MAKE_VERSION(
131 context_vk.context_major_version_, context_vk.context_minor_version_, 0);
133 if (extensions_.vulkan_enable) {
134 XrGraphicsRequirementsVulkanKHR xr_graphics_requirements{
135 XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR,
138 if (XR_FAILED(functions_.xrGetVulkanGraphicsRequirementsKHR(
139 instance, system_id, &xr_graphics_requirements)))
141 *r_requirement_info = std::string(
"Unable to retrieve Xr version requirements for Vulkan");
146 if (vk_version < xr_graphics_requirements.minApiVersionSupported) {
148 strstream <<
"Min Vulkan version "
149 << XR_VERSION_MAJOR(xr_graphics_requirements.minApiVersionSupported) <<
"."
150 << XR_VERSION_MINOR(xr_graphics_requirements.minApiVersionSupported) << std::endl;
152 if (vk_version > xr_graphics_requirements.maxApiVersionSupported) {
154 "OpenXR platform vulkan version requirements do not match with Blender. "
155 "This is known to happen when using Oculus/Meta Quest. A workaround for this is "
156 "already enabled by enabling extensions that are known to be in core vulkan. "
157 "(minimum vulkan version=%d.%d, maximum vulkan version=%d.%d).",
158 XR_VERSION_MAJOR(xr_graphics_requirements.minApiVersionSupported),
159 XR_VERSION_MINOR(xr_graphics_requirements.minApiVersionSupported),
160 XR_VERSION_MAJOR(xr_graphics_requirements.maxApiVersionSupported),
161 XR_VERSION_MINOR(xr_graphics_requirements.maxApiVersionSupported));
165 if (extensions_.vulkan_enable2) {
166 XrGraphicsRequirementsVulkanKHR xr_graphics_requirements2{
167 XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR,
170 if (XR_FAILED(functions_.xrGetVulkanGraphicsRequirements2KHR(
171 instance, system_id, &xr_graphics_requirements2)))
173 *r_requirement_info = std::string(
"Unable to retrieve Xr version requirements for Vulkan");
177 if (vk_version < xr_graphics_requirements2.minApiVersionSupported) {
179 strstream <<
"Min Vulkan version "
180 << XR_VERSION_MAJOR(xr_graphics_requirements2.minApiVersionSupported) <<
"."
181 << XR_VERSION_MINOR(xr_graphics_requirements2.minApiVersionSupported) << std::endl;
183 if (vk_version > xr_graphics_requirements2.maxApiVersionSupported) {
185 "OpenXR platform vulkan version requirements do not match with Blender. "
186 "This is known to happen when using Oculus/Meta Quest. A workaround for this is "
187 "already enabled by enabling extensions that are known to be in core vulkan. "
188 "(minimum vulkan version=%d.%d, maximum vulkan version=%d.%d).",
189 XR_VERSION_MAJOR(xr_graphics_requirements2.minApiVersionSupported),
190 XR_VERSION_MINOR(xr_graphics_requirements2.minApiVersionSupported),
191 XR_VERSION_MAJOR(xr_graphics_requirements2.maxApiVersionSupported),
192 XR_VERSION_MINOR(xr_graphics_requirements2.maxApiVersionSupported));
198 if (!strstream.str().empty()) {
199 *r_requirement_info = strstream.str();
208 XrSystemId system_id)
210 if (tryReuseVulkanInstance(
static_cast<GHOST_ContextVK &
>(ghost_ctx), instance, system_id)) {
214 VkApplicationInfo vk_application_info = {VK_STRUCTURE_TYPE_APPLICATION_INFO,
217 VK_MAKE_VERSION(1, 0, 0),
219 VK_MAKE_VERSION(1, 0, 0),
220 VK_MAKE_VERSION(1, 1, 0)};
221 VkInstanceCreateInfo vk_instance_create_info = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
224 &vk_application_info,
229 XrVulkanInstanceCreateInfoKHR xr_instance_create_info = {XR_TYPE_VULKAN_INSTANCE_CREATE_INFO_KHR,
233 vkGetInstanceProcAddr,
234 &vk_instance_create_info,
237 CHECK_XR(functions_.xrCreateVulkanInstanceKHR(
238 instance, &xr_instance_create_info, &vk_instance_, &vk_result),
239 "Unable to create an OpenXR compatible Vulkan instance.");
242 XrVulkanGraphicsDeviceGetInfoKHR xr_device_get_info = {
243 XR_TYPE_VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR,
nullptr, system_id, vk_instance_};
244 CHECK_XR(functions_.xrGetVulkanGraphicsDevice2KHR(
245 instance, &xr_device_get_info, &vk_physical_device_),
246 "Unable to create an OpenXR compatible Vulkan physical device.");
249 uint32_t vk_queue_family_count = 0;
250 vkGetPhysicalDeviceQueueFamilyProperties(vk_physical_device_, &vk_queue_family_count,
nullptr);
251 std::vector<VkQueueFamilyProperties> vk_queue_families(vk_queue_family_count);
252 graphics_queue_family_ = 0;
253 vkGetPhysicalDeviceQueueFamilyProperties(
254 vk_physical_device_, &vk_queue_family_count, vk_queue_families.data());
255 for (uint32_t i = 0; i < vk_queue_family_count; i++) {
256 if (vk_queue_families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT &&
257 vk_queue_families[i].queueFlags & VK_QUEUE_TRANSFER_BIT)
259 graphics_queue_family_ = i;
265 const float queue_priority = 1.0f;
266 VkDeviceQueueCreateInfo vk_queue_create_info = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
269 graphics_queue_family_,
272 VkDeviceCreateInfo vk_device_create_info = {VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
276 &vk_queue_create_info,
281 XrVulkanDeviceCreateInfoKHR xr_device_create_info = {XR_TYPE_VULKAN_DEVICE_CREATE_INFO_KHR,
285 vkGetInstanceProcAddr,
287 &vk_device_create_info,
289 CHECK_XR(functions_.xrCreateVulkanDeviceKHR(
290 instance, &xr_device_create_info, &vk_device_, &vk_result),
291 "Unable to create an OpenXR compatible Vulkan logical device.");
292 volkLoadDeviceTable(&functions, vk_device_);
294 functions.vkGetDeviceQueue(vk_device_, graphics_queue_family_, 0, &vk_queue_);
297 VkCommandPoolCreateInfo vk_command_pool_create_info = {
298 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
300 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
301 graphics_queue_family_};
302 functions.vkCreateCommandPool(
303 vk_device_, &vk_command_pool_create_info,
nullptr, &vk_command_pool_);
306 VkCommandBufferAllocateInfo vk_command_buffer_allocate_info = {
307 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
310 VK_COMMAND_BUFFER_LEVEL_PRIMARY,
312 functions.vkAllocateCommandBuffers(
313 vk_device_, &vk_command_buffer_allocate_info, &vk_command_buffer_);
316 data_transfer_mode_ = choseDataTransferMode();
318 if (data_transfer_mode_ == GHOST_kVulkanXRModeCPU) {
320 VmaAllocatorCreateInfo allocator_create_info = {};
321 allocator_create_info.flags = VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT;
322 allocator_create_info.vulkanApiVersion = VK_API_VERSION_1_1;
323 allocator_create_info.physicalDevice = vk_physical_device_;
324 allocator_create_info.device = vk_device_;
325 allocator_create_info.instance = vk_instance_;
326 VmaVulkanFunctions vma_vulkan_functions = {};
327 vmaImportVulkanFunctionsFromVolk(&allocator_create_info, &vma_vulkan_functions);
328 allocator_create_info.pVulkanFunctions = &vma_vulkan_functions;
329 vmaCreateAllocator(&allocator_create_info, &vma_allocator_);
333 oxr_binding.vk.type = XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR;
336 oxr_binding.vk.physicalDevice = vk_physical_device_;
338 oxr_binding.vk.queueFamilyIndex = graphics_queue_family_;
342bool GHOST_XrGraphicsBindingVulkan::tryReuseVulkanInstance(
GHOST_ContextVK &ghost_ctx,
344 XrSystemId system_id)
346 if (!extensions_.vulkan_enable) {
348 "Unable to reuse vulkan instance: XR_KHR_vulkan_enable isn't supported");
352 GHOST_VulkanHandles context_handles;
361 result &= areRequiredInstanceExtensionsEnabled(instance, system_id);
362 result &= areRequiredDeviceExtensionsEnabled(instance, system_id);
363 result &= isSamePhysicalDeviceSelected(instance, system_id, context_handles);
370 data_transfer_mode_ = GHOST_kVulkanXRModeRenderGraph;
373 oxr_binding.vk.type = XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR;
375 oxr_binding.vk.instance = context_handles.instance;
376 oxr_binding.vk.physicalDevice = context_handles.physical_device;
378 oxr_binding.vk.queueFamilyIndex = context_handles.graphic_queue_family;
386 std::stringstream ss(extension_names);
387 std::string extension_name;
389 while (std::getline(ss, extension_name,
' ')) {
390 if (!extension_name.empty()) {
391 result.append(extension_name);
398bool GHOST_XrGraphicsBindingVulkan::areRequiredInstanceExtensionsEnabled(
399 XrInstance instance, XrSystemId system_id)
const
402 functions_.xrGetVulkanInstanceExtensionsKHR(instance, system_id, 0, &buffer_count,
nullptr);
403 std::string buffer(buffer_count,
'\0');
404 functions_.xrGetVulkanInstanceExtensionsKHR(
405 instance, system_id,
uint32_t(buffer.size()), &buffer_count, buffer.data());
407 bool all_extensions_enabled =
true;
408 std::stringstream log_ss;
409 log_ss <<
"Required vulkan instance extensions:";
410 for (
const std::string &extension_name : instance_extension_names) {
412 extension_name.c_str());
413 log_ss <<
"\n - [" << (is_extension_enabled ?
'X' :
' ') <<
"] " << extension_name;
414 all_extensions_enabled &= is_extension_enabled;
417 if (!all_extensions_enabled) {
419 "Unable to reuse vulkan instance: not all required instance extensions are enabled");
426bool GHOST_XrGraphicsBindingVulkan::areRequiredDeviceExtensionsEnabled(XrInstance instance,
427 XrSystemId system_id)
const
430 functions_.xrGetVulkanDeviceExtensionsKHR(instance, system_id, 0, &buffer_count,
nullptr);
431 std::string buffer(buffer_count,
'\0');
432 functions_.xrGetVulkanDeviceExtensionsKHR(
433 instance, system_id,
uint32_t(buffer.size()), &buffer_count, buffer.data());
435 bool all_extensions_enabled =
true;
436 std::stringstream log_ss;
437 log_ss <<
"Required vulkan device extensions:";
438 for (
const std::string &extension_name : instance_extension_names) {
440 extension_name.c_str());
441 log_ss <<
"\n - [" << (is_extension_enabled ?
'X' :
' ') <<
"] " << extension_name;
442 all_extensions_enabled &= is_extension_enabled;
445 if (!all_extensions_enabled) {
447 "Unable to reuse vulkan instance: not all required device extensions are enabled");
454bool GHOST_XrGraphicsBindingVulkan::isSamePhysicalDeviceSelected(
455 XrInstance instance, XrSystemId system_id,
const GHOST_VulkanHandles &context_handles)
const
457 VkPhysicalDevice openxr_physical_device = VK_NULL_HANDLE;
458 functions_.xrGetVulkanGraphicsDeviceKHR(
459 instance, system_id, context_handles.instance, &openxr_physical_device);
460 if (context_handles.physical_device != openxr_physical_device) {
461 VkPhysicalDeviceProperties openxr_physical_device_properties = {};
462 vkGetPhysicalDeviceProperties(openxr_physical_device, &openxr_physical_device_properties);
463 VkPhysicalDeviceProperties context_physical_device_properties = {};
464 vkGetPhysicalDeviceProperties(context_handles.physical_device,
465 &context_physical_device_properties);
467 "Unable to reuse vulkan instance: OpenXR requires to use a different GPU [%s] than "
468 "currently in used [%s].",
469 openxr_physical_device_properties.deviceName,
470 context_physical_device_properties.deviceName);
476GHOST_TVulkanXRModes GHOST_XrGraphicsBindingVulkan::choseDataTransferMode()
478 GHOST_VulkanHandles vulkan_handles;
479 ghost_ctx_.getVulkanHandles(vulkan_handles);
482 VkPhysicalDeviceVulkan11Properties vk_physical_device_vulkan11_properties = {
483 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES};
484 VkPhysicalDeviceProperties2 vk_physical_device_properties = {
485 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, &vk_physical_device_vulkan11_properties};
486 vkGetPhysicalDeviceProperties2(vulkan_handles.physical_device, &vk_physical_device_properties);
489 VkPhysicalDeviceVulkan11Properties xr_physical_device_vulkan11_properties = {
490 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES};
491 VkPhysicalDeviceProperties2 xr_physical_device_properties = {
492 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, &xr_physical_device_vulkan11_properties};
493 vkGetPhysicalDeviceProperties2(vk_physical_device_, &xr_physical_device_properties);
498 const bool is_same_physical_device = memcmp(&vk_physical_device_vulkan11_properties,
499 &xr_physical_device_vulkan11_properties,
500 sizeof(VkPhysicalDeviceVulkan11Properties)) == 0;
501 if (!is_same_physical_device) {
502 return GHOST_kVulkanXRModeCPU;
508 vkEnumerateDeviceExtensionProperties(
509 vulkan_handles.physical_device,
nullptr, &device_extension_count,
nullptr);
510 std::vector<VkExtensionProperties> available_device_extensions(device_extension_count);
511 vkEnumerateDeviceExtensionProperties(vulkan_handles.physical_device,
513 &device_extension_count,
514 available_device_extensions.data());
516 auto has_extension = [=](
const char *extension_name) {
517 for (
const auto &extension : available_device_extensions) {
518 if (
STREQ(extension_name, extension.extensionName)) {
526 bool has_vk_khr_external_memory_win32_extension = has_extension(
527 VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME);
528 if (has_vk_khr_external_memory_win32_extension) {
529 return GHOST_kVulkanXRModeWin32;
531#elif defined(__APPLE__)
533 bool has_vk_khr_external_memory_fd_extension = has_extension(
534 VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME);
535 if (has_vk_khr_external_memory_fd_extension) {
536 return GHOST_kVulkanXRModeFD;
540 return GHOST_kVulkanXRModeCPU;
544 const std::vector<int64_t> &gpu_binding_formats,
const std::vector<int64_t> &runtime_formats)
546 if (gpu_binding_formats.empty()) {
550 auto res = std::find_first_of(gpu_binding_formats.begin(),
551 gpu_binding_formats.end(),
552 runtime_formats.begin(),
553 runtime_formats.end());
554 if (res == gpu_binding_formats.end()) {
562 const std::vector<int64_t> &runtime_formats,
563 GHOST_TXrSwapchainFormat &r_format,
564 bool &r_is_srgb_format)
const
566 std::vector<int64_t> gpu_binding_formats = {
567 VK_FORMAT_R16G16B16A16_SFLOAT,
569 VK_FORMAT_B8G8R8A8_UNORM,
571 VK_FORMAT_B8G8R8A8_SRGB,
574 r_format = GHOST_kXrSwapchainFormatRGBA8;
575 r_is_srgb_format =
false;
580 case VK_FORMAT_R16G16B16A16_SFLOAT:
581 r_format = GHOST_kXrSwapchainFormatRGBA16F;
584 case VK_FORMAT_B8G8R8A8_UNORM:
586 case VK_FORMAT_B8G8R8A8_SRGB:
587 r_format = GHOST_kXrSwapchainFormatRGBA8;
594 if (data_transfer_mode_ != GHOST_kVulkanXRModeRenderGraph) {
596 case VK_FORMAT_R16G16B16A16_SFLOAT:
598 case VK_FORMAT_B8G8R8A8_UNORM:
599 r_is_srgb_format =
false;
602 case VK_FORMAT_B8G8R8A8_SRGB:
603 r_is_srgb_format =
true;
612 uint32_t image_count)
614 std::vector<XrSwapchainImageBaseHeader *> base_images;
615 std::vector<XrSwapchainImageVulkan2KHR> vulkan_images(
616 image_count, {XR_TYPE_SWAPCHAIN_IMAGE_VULKAN2_KHR,
nullptr, VK_NULL_HANDLE});
617 for (XrSwapchainImageVulkan2KHR &
image : vulkan_images) {
618 base_images.push_back(
reinterpret_cast<XrSwapchainImageBaseHeader *
>(&
image));
620 image_cache_.push_back(std::move(vulkan_images));
627 XrSwapchainImageBaseHeader &swapchain_image,
const GHOST_XrDrawViewInfo &draw_info)
629 XrSwapchainImageVulkan2KHR &vulkan_image = *
reinterpret_cast<XrSwapchainImageVulkan2KHR *
>(
632 switch (data_transfer_mode_) {
633 case GHOST_kVulkanXRModeFD:
634 case GHOST_kVulkanXRModeWin32:
635 submitToSwapchainImageGpu(vulkan_image, draw_info);
638 case GHOST_kVulkanXRModeCPU:
639 submitToSwapchainImageCpu(vulkan_image, draw_info);
642 case GHOST_kVulkanXRModeRenderGraph:
643 submitToSwapchainImageRenderGraph(vulkan_image, draw_info);
653void GHOST_XrGraphicsBindingVulkan::submitToSwapchainImageCpu(
654 XrSwapchainImageVulkan2KHR &swapchain_image,
const GHOST_XrDrawViewInfo &draw_info)
657 GHOST_VulkanOpenXRData openxr_data = {GHOST_kVulkanXRModeCPU};
658 ghost_ctx_.openxr_acquire_framebuffer_image_callback_(&openxr_data);
661 VkDeviceSize component_size = 4 *
sizeof(
uint8_t);
662 if (
ELEM(draw_info.swapchain_format,
663 GHOST_kXrSwapchainFormatRGBA16F,
664 GHOST_kXrSwapchainFormatRGBA16))
666 component_size = 4 *
sizeof(
uint16_t);
668 VkDeviceSize image_data_size = openxr_data.extent.width * openxr_data.extent.height *
671 if (vk_buffer_ != VK_NULL_HANDLE && vk_buffer_allocation_info_.size < image_data_size) {
672 vmaUnmapMemory(vma_allocator_, vk_buffer_allocation_);
673 vmaDestroyBuffer(vma_allocator_, vk_buffer_, vk_buffer_allocation_);
674 vk_buffer_ = VK_NULL_HANDLE;
675 vk_buffer_allocation_ = VK_NULL_HANDLE;
678 if (vk_buffer_ == VK_NULL_HANDLE) {
679 VkBufferCreateInfo vk_buffer_create_info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
683 VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
684 VK_SHARING_MODE_EXCLUSIVE,
687 VmaAllocationCreateInfo allocation_create_info = {};
688 allocation_create_info.usage = VMA_MEMORY_USAGE_AUTO;
689 allocation_create_info.flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
690 allocation_create_info.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
691 vmaCreateBuffer(vma_allocator_,
692 &vk_buffer_create_info,
693 &allocation_create_info,
695 &vk_buffer_allocation_,
696 &vk_buffer_allocation_info_);
697 vmaMapMemory(vma_allocator_, vk_buffer_allocation_, &vk_buffer_allocation_info_.pMappedData);
699 std::memcpy(vk_buffer_allocation_info_.pMappedData, openxr_data.cpu.image_data, image_data_size);
702 VkCommandBuffer vk_command_buffer = vk_command_buffer_;
705 VkCommandBufferBeginInfo vk_command_buffer_begin_info = {
706 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
708 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
710 functions.vkBeginCommandBuffer(vk_command_buffer, &vk_command_buffer_begin_info);
713 VkImageMemoryBarrier vk_image_memory_barrier = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
716 VK_ACCESS_TRANSFER_WRITE_BIT,
717 VK_IMAGE_LAYOUT_UNDEFINED,
718 VK_IMAGE_LAYOUT_GENERAL,
719 VK_QUEUE_FAMILY_IGNORED,
720 VK_QUEUE_FAMILY_IGNORED,
721 swapchain_image.image,
722 {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}};
723 functions.vkCmdPipelineBarrier(vk_command_buffer,
724 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
725 VK_PIPELINE_STAGE_TRANSFER_BIT,
732 &vk_image_memory_barrier);
735 VkBufferImageCopy vk_buffer_image_copy = {
739 {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1},
740 {draw_info.ofsx, draw_info.ofsy, 0},
741 {openxr_data.extent.width, openxr_data.extent.height, 1}};
742 functions.vkCmdCopyBufferToImage(vk_command_buffer,
744 swapchain_image.image,
745 VK_IMAGE_LAYOUT_GENERAL,
747 &vk_buffer_image_copy);
750 functions.vkEndCommandBuffer(vk_command_buffer);
752 VkSubmitInfo vk_submit_info = {
753 VK_STRUCTURE_TYPE_SUBMIT_INFO,
nullptr, 0,
nullptr,
nullptr, 1, &vk_command_buffer};
754 functions.vkQueueSubmit(vk_queue_, 1, &vk_submit_info, VK_NULL_HANDLE);
757 functions.vkQueueWaitIdle(vk_queue_);
760 functions.vkResetCommandBuffer(vk_command_buffer, 0);
763 ghost_ctx_.openxr_release_framebuffer_image_callback_(&openxr_data);
772void GHOST_XrGraphicsBindingVulkan::submitToSwapchainImageRenderGraph(
773 XrSwapchainImageVulkan2KHR &swapchain_image,
const GHOST_XrDrawViewInfo &draw_info)
775 const bool is_last_view = draw_info.view_idx == image_cache_.size() - 1;
777 GHOST_VulkanSwapChainData swap_chain_data = {};
778 swap_chain_data.image = swapchain_image.image;
779 swap_chain_data.extent = {
uint32_t(draw_info.width),
uint32_t(draw_info.height)};
780 swap_chain_data.surface_format.format = VkFormat(draw_info.gpu_swapchain_format);
781 swap_chain_data.surface_format.colorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
783 ghost_ctx_.swap_buffer_draw_callback_(&swap_chain_data, is_last_view);
792void GHOST_XrGraphicsBindingVulkan::submitToSwapchainImageGpu(
793 XrSwapchainImageVulkan2KHR &swapchain_image,
const GHOST_XrDrawViewInfo &draw_info)
796 ImportedMemory *imported_memory =
nullptr;
797 for (ImportedMemory &item : imported_memory_) {
798 if (item.view_idx == draw_info.view_idx) {
799 imported_memory = &item;
803 if (imported_memory ==
nullptr) {
804 imported_memory_.push_back(
805 {draw_info.view_idx, VK_NULL_HANDLE, VK_NULL_HANDLE, VK_NULL_HANDLE});
806 imported_memory = &imported_memory_.back();
809 GHOST_VulkanOpenXRData openxr_data = {data_transfer_mode_};
810 openxr_data.gpu.vk_image_blender = imported_memory->vk_image_blender;
811 ghost_ctx_.openxr_acquire_framebuffer_image_callback_(&openxr_data);
812 imported_memory->vk_image_blender = openxr_data.gpu.vk_image_blender;
815 if (openxr_data.gpu.new_handle) {
816 if (imported_memory->vk_image_xr) {
817 functions.vkDestroyImage(vk_device_, imported_memory->vk_image_xr,
nullptr);
818 functions.vkFreeMemory(vk_device_, imported_memory->vk_device_memory_xr,
nullptr);
819 imported_memory->vk_device_memory_xr = VK_NULL_HANDLE;
820 imported_memory->vk_image_xr = VK_NULL_HANDLE;
823 VkExternalMemoryImageCreateInfo vk_external_memory_image_info = {
824 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
nullptr, 0};
826 switch (data_transfer_mode_) {
827 case GHOST_kVulkanXRModeFD:
828 vk_external_memory_image_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
830 case GHOST_kVulkanXRModeWin32:
831 vk_external_memory_image_info.handleTypes =
832 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
834 case GHOST_kVulkanXRModeCPU:
835 case GHOST_kVulkanXRModeRenderGraph:
839 VkImageCreateInfo vk_image_info = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
840 &vk_external_memory_image_info,
843 openxr_data.gpu.image_format,
844 {openxr_data.extent.width, openxr_data.extent.height, 1},
847 VK_SAMPLE_COUNT_1_BIT,
848 VK_IMAGE_TILING_OPTIMAL,
849 VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
850 VK_SHARING_MODE_EXCLUSIVE,
853 VK_IMAGE_LAYOUT_UNDEFINED};
855 functions.vkCreateImage(vk_device_, &vk_image_info,
nullptr, &imported_memory->vk_image_xr);
858 VkMemoryRequirements vk_memory_requirements = {};
859 functions.vkGetImageMemoryRequirements(
860 vk_device_, imported_memory->vk_image_xr, &vk_memory_requirements);
863 VkMemoryDedicatedAllocateInfo vk_memory_dedicated_allocation_info = {
864 VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
866 imported_memory->vk_image_xr,
868 switch (data_transfer_mode_) {
869 case GHOST_kVulkanXRModeFD: {
870 VkImportMemoryFdInfoKHR import_memory_info = {VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,
871 &vk_memory_dedicated_allocation_info,
872 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
873 int(openxr_data.gpu.image_handle)};
874 VkMemoryAllocateInfo allocate_info = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
876 vk_memory_requirements.size};
877 functions.vkAllocateMemory(
878 vk_device_, &allocate_info,
nullptr, &imported_memory->vk_device_memory_xr);
882 case GHOST_kVulkanXRModeWin32: {
884 VkImportMemoryWin32HandleInfoKHR import_memory_info = {
885 VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
886 &vk_memory_dedicated_allocation_info,
887 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
888 HANDLE(openxr_data.gpu.image_handle)};
889 VkMemoryAllocateInfo allocate_info = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
891 vk_memory_requirements.size};
892 functions.vkAllocateMemory(
893 vk_device_, &allocate_info,
nullptr, &imported_memory->vk_device_memory_xr);
898 case GHOST_kVulkanXRModeCPU:
899 case GHOST_kVulkanXRModeRenderGraph:
904 functions.vkBindImageMemory(vk_device_,
905 imported_memory->vk_image_xr,
906 imported_memory->vk_device_memory_xr,
907 openxr_data.gpu.memory_offset);
911 VkCommandBuffer vk_command_buffer = vk_command_buffer_;
914 VkCommandBufferBeginInfo vk_command_buffer_begin_info = {
915 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
917 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
919 functions.vkBeginCommandBuffer(vk_command_buffer, &vk_command_buffer_begin_info);
922 VkImageMemoryBarrier vk_image_memory_barrier[] = {{VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
925 VK_ACCESS_TRANSFER_READ_BIT,
926 VK_IMAGE_LAYOUT_UNDEFINED,
927 VK_IMAGE_LAYOUT_GENERAL,
928 VK_QUEUE_FAMILY_IGNORED,
929 VK_QUEUE_FAMILY_IGNORED,
930 imported_memory->vk_image_xr,
931 {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}},
932 {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
935 VK_ACCESS_TRANSFER_WRITE_BIT,
936 VK_IMAGE_LAYOUT_UNDEFINED,
937 VK_IMAGE_LAYOUT_GENERAL,
938 VK_QUEUE_FAMILY_IGNORED,
939 VK_QUEUE_FAMILY_IGNORED,
940 swapchain_image.image,
941 {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}}};
942 functions.vkCmdPipelineBarrier(vk_command_buffer,
943 VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
944 VK_PIPELINE_STAGE_TRANSFER_BIT,
951 vk_image_memory_barrier);
954 VkImageCopy vk_image_copy = {{VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1},
956 {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1},
957 {draw_info.ofsx, draw_info.ofsy, 0},
958 {openxr_data.extent.width, openxr_data.extent.height, 1}};
959 functions.vkCmdCopyImage(vk_command_buffer,
960 imported_memory->vk_image_xr,
961 VK_IMAGE_LAYOUT_GENERAL,
962 swapchain_image.image,
963 VK_IMAGE_LAYOUT_GENERAL,
968 VkImageMemoryBarrier vk_image_memory_barrier2 = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
970 VK_ACCESS_TRANSFER_WRITE_BIT,
972 VK_IMAGE_LAYOUT_GENERAL,
973 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
974 VK_QUEUE_FAMILY_IGNORED,
975 VK_QUEUE_FAMILY_IGNORED,
976 swapchain_image.image,
977 {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}};
978 functions.vkCmdPipelineBarrier(vk_command_buffer,
979 VK_PIPELINE_STAGE_TRANSFER_BIT,
980 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
987 &vk_image_memory_barrier2);
990 functions.vkEndCommandBuffer(vk_command_buffer);
992 VkSubmitInfo vk_submit_info = {
993 VK_STRUCTURE_TYPE_SUBMIT_INFO,
nullptr, 0,
nullptr,
nullptr, 1, &vk_command_buffer};
994 functions.vkQueueSubmit(vk_queue_, 1, &vk_submit_info, VK_NULL_HANDLE);
997 functions.vkQueueWaitIdle(vk_queue_);
1000 functions.vkResetCommandBuffer(vk_command_buffer, 0);
1007 if (data_transfer_mode_ == GHOST_kVulkanXRModeRenderGraph) {
#define CLOG_DEBUG(clg_ref,...)
#define CLOG_INFO(clg_ref,...)
#define LOAD_FUNCTION(fn_ptr, name)
static std::optional< int64_t > choose_swapchain_format_from_candidates(const std::vector< int64_t > &gpu_binding_formats, const std::vector< int64_t > &runtime_formats)
static blender::Vector< std::string > split_extension_names(blender::StringRef extension_names)
CLG_LogRef * LOG_GHOST_XR
#define CHECK_XR(call, error_msg)
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?
static bool is_device_extension_enabled(blender::StringRefNull extension_name)
Is the given extension name enabled on device level?
virtual bool isUpsideDown() const
GHOST_IXrGraphicsBinding()=default
union GHOST_IXrGraphicsBinding::@011235222313272276112307021312244353112200226155 oxr_binding
std::vector< XrSwapchainImageBaseHeader * > createSwapchainImages(uint32_t image_count) override
std::optional< int64_t > chooseSwapchainFormat(const std::vector< int64_t > &runtime_formats, GHOST_TXrSwapchainFormat &r_format, bool &r_is_srgb_format) const override
~GHOST_XrGraphicsBindingVulkan() override
void initFromGhostContext(GHOST_Context &ghost_ctx, XrInstance instance, XrSystemId system_id) override
void submitToSwapchainImage(XrSwapchainImageBaseHeader &swapchain_image, const GHOST_XrDrawViewInfo &draw_info) override
void submitToSwapchainEnd() override
bool loadExtensionFunctions(XrInstance instance) override
load the functions for the graphics binding.
bool needsUpsideDownDrawing(GHOST_Context &ghost_ctx) const override
bool checkVersionRequirements(GHOST_Context &ghost_ctx, XrInstance instance, XrSystemId system_id, std::string *r_requirement_info) const override
GHOST_XrGraphicsBindingVulkan(GHOST_Context &ghost_ctx)
void submitToSwapchainBegin() override
#define image(slot, qualifiers, format)
#define VK_FORMAT_R8G8B8A8_UNORM
#define VK_FORMAT_R8G8B8A8_SRGB