2021-12-14 01:44:12 +00:00
|
|
|
/**************************************************************************/
|
|
|
|
|
/* openxr_vulkan_extension.cpp */
|
|
|
|
|
/**************************************************************************/
|
|
|
|
|
/* This file is part of: */
|
|
|
|
|
/* GODOT ENGINE */
|
|
|
|
|
/* https://godotengine.org */
|
|
|
|
|
/**************************************************************************/
|
|
|
|
|
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
|
|
|
|
|
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
|
|
|
|
|
/* */
|
|
|
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
|
|
|
/* a copy of this software and associated documentation files (the */
|
|
|
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
|
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
|
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
|
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
|
|
|
/* the following conditions: */
|
|
|
|
|
/* */
|
|
|
|
|
/* The above copyright notice and this permission notice shall be */
|
|
|
|
|
/* included in all copies or substantial portions of the Software. */
|
|
|
|
|
/* */
|
|
|
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
|
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
|
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
|
|
|
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
|
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
|
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
|
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
|
|
|
/**************************************************************************/
|
|
|
|
|
|
2023-06-13 14:56:21 +00:00
|
|
|
#include "openxr_vulkan_extension.h"
|
2021-12-14 01:44:12 +00:00
|
|
|
|
2023-12-27 03:49:25 +00:00
|
|
|
#include "../../openxr_util.h"
|
2023-06-13 14:56:21 +00:00
|
|
|
|
|
|
|
|
#include "core/string/print_string.h"
|
2022-04-29 07:10:54 +00:00
|
|
|
#include "servers/rendering/renderer_rd/effects/copy_effects.h"
|
2022-04-07 14:00:51 +00:00
|
|
|
#include "servers/rendering/renderer_rd/storage_rd/texture_storage.h"
|
2021-12-14 01:44:12 +00:00
|
|
|
#include "servers/rendering/rendering_server_globals.h"
|
|
|
|
|
#include "servers/rendering_server.h"
|
|
|
|
|
|
2022-12-29 05:34:25 +00:00
|
|
|
OpenXRVulkanExtension::OpenXRVulkanExtension() {
|
2021-12-14 01:44:12 +00:00
|
|
|
VulkanContext::set_vulkan_hooks(this);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
OpenXRVulkanExtension::~OpenXRVulkanExtension() {
|
|
|
|
|
VulkanContext::set_vulkan_hooks(nullptr);
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-29 05:34:25 +00:00
|
|
|
HashMap<String, bool *> OpenXRVulkanExtension::get_requested_extensions() {
|
|
|
|
|
HashMap<String, bool *> request_extensions;
|
|
|
|
|
|
|
|
|
|
request_extensions[XR_KHR_VULKAN_ENABLE2_EXTENSION_NAME] = nullptr; // must be available
|
|
|
|
|
|
|
|
|
|
return request_extensions;
|
|
|
|
|
}
|
|
|
|
|
|
2021-12-14 01:44:12 +00:00
|
|
|
void OpenXRVulkanExtension::on_instance_created(const XrInstance p_instance) {
|
2022-12-29 05:34:25 +00:00
|
|
|
ERR_FAIL_NULL(OpenXRAPI::get_singleton());
|
2021-12-14 01:44:12 +00:00
|
|
|
|
|
|
|
|
// Obtain pointers to functions we're accessing here, they are (not yet) part of core.
|
|
|
|
|
|
2022-09-24 11:56:00 +00:00
|
|
|
EXT_INIT_XR_FUNC(xrGetVulkanGraphicsRequirements2KHR);
|
|
|
|
|
EXT_INIT_XR_FUNC(xrCreateVulkanInstanceKHR);
|
|
|
|
|
EXT_INIT_XR_FUNC(xrGetVulkanGraphicsDevice2KHR);
|
|
|
|
|
EXT_INIT_XR_FUNC(xrCreateVulkanDeviceKHR);
|
|
|
|
|
EXT_INIT_XR_FUNC(xrEnumerateSwapchainImages);
|
2021-12-14 01:44:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool OpenXRVulkanExtension::check_graphics_api_support(XrVersion p_desired_version) {
|
2022-12-29 05:34:25 +00:00
|
|
|
ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), false);
|
2021-12-14 01:44:12 +00:00
|
|
|
|
|
|
|
|
XrGraphicsRequirementsVulkan2KHR vulkan_requirements = {
|
|
|
|
|
XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN2_KHR, // type
|
|
|
|
|
nullptr, // next
|
|
|
|
|
0, // minApiVersionSupported
|
|
|
|
|
0 // maxApiVersionSupported
|
|
|
|
|
};
|
|
|
|
|
|
2022-12-29 05:34:25 +00:00
|
|
|
XrResult result = xrGetVulkanGraphicsRequirements2KHR(OpenXRAPI::get_singleton()->get_instance(), OpenXRAPI::get_singleton()->get_system_id(), &vulkan_requirements);
|
2021-12-14 01:44:12 +00:00
|
|
|
if (XR_FAILED(result)) {
|
2022-12-29 05:34:25 +00:00
|
|
|
print_line("OpenXR: Failed to get vulkan graphics requirements [", OpenXRAPI::get_singleton()->get_error_string(result), "]");
|
2021-12-14 01:44:12 +00:00
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// #ifdef DEBUG
|
|
|
|
|
print_line("OpenXR: XrGraphicsRequirementsVulkan2KHR:");
|
|
|
|
|
print_line(" - minApiVersionSupported: ", OpenXRUtil::make_xr_version_string(vulkan_requirements.minApiVersionSupported));
|
|
|
|
|
print_line(" - maxApiVersionSupported: ", OpenXRUtil::make_xr_version_string(vulkan_requirements.maxApiVersionSupported));
|
|
|
|
|
// #endif
|
|
|
|
|
|
|
|
|
|
if (p_desired_version < vulkan_requirements.minApiVersionSupported) {
|
|
|
|
|
print_line("OpenXR: Requested Vulkan version does not meet the minimum version this runtime supports.");
|
|
|
|
|
print_line("- desired_version ", OpenXRUtil::make_xr_version_string(p_desired_version));
|
|
|
|
|
print_line("- minApiVersionSupported ", OpenXRUtil::make_xr_version_string(vulkan_requirements.minApiVersionSupported));
|
|
|
|
|
print_line("- maxApiVersionSupported ", OpenXRUtil::make_xr_version_string(vulkan_requirements.maxApiVersionSupported));
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (p_desired_version > vulkan_requirements.maxApiVersionSupported) {
|
|
|
|
|
print_line("OpenXR: Requested Vulkan version exceeds the maximum version this runtime has been tested on and is known to support.");
|
|
|
|
|
print_line("- desired_version ", OpenXRUtil::make_xr_version_string(p_desired_version));
|
|
|
|
|
print_line("- minApiVersionSupported ", OpenXRUtil::make_xr_version_string(vulkan_requirements.minApiVersionSupported));
|
|
|
|
|
print_line("- maxApiVersionSupported ", OpenXRUtil::make_xr_version_string(vulkan_requirements.maxApiVersionSupported));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool OpenXRVulkanExtension::create_vulkan_instance(const VkInstanceCreateInfo *p_vulkan_create_info, VkInstance *r_instance) {
|
|
|
|
|
// get the vulkan version we are creating
|
|
|
|
|
uint32_t vulkan_version = p_vulkan_create_info->pApplicationInfo->apiVersion;
|
|
|
|
|
uint32_t major_version = VK_VERSION_MAJOR(vulkan_version);
|
|
|
|
|
uint32_t minor_version = VK_VERSION_MINOR(vulkan_version);
|
|
|
|
|
uint32_t patch_version = VK_VERSION_PATCH(vulkan_version);
|
|
|
|
|
XrVersion desired_version = XR_MAKE_VERSION(major_version, minor_version, patch_version);
|
|
|
|
|
|
|
|
|
|
// check if this is supported
|
|
|
|
|
if (!check_graphics_api_support(desired_version)) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
XrVulkanInstanceCreateInfoKHR xr_vulkan_instance_info = {
|
|
|
|
|
XR_TYPE_VULKAN_INSTANCE_CREATE_INFO_KHR, // type
|
|
|
|
|
nullptr, // next
|
2022-12-29 05:34:25 +00:00
|
|
|
OpenXRAPI::get_singleton()->get_system_id(), // systemId
|
2021-12-14 01:44:12 +00:00
|
|
|
0, // createFlags
|
|
|
|
|
vkGetInstanceProcAddr, // pfnGetInstanceProcAddr
|
|
|
|
|
p_vulkan_create_info, // vulkanCreateInfo
|
|
|
|
|
nullptr, // vulkanAllocator
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
VkResult vk_result = VK_SUCCESS;
|
2022-12-29 05:34:25 +00:00
|
|
|
XrResult result = xrCreateVulkanInstanceKHR(OpenXRAPI::get_singleton()->get_instance(), &xr_vulkan_instance_info, &vulkan_instance, &vk_result);
|
2021-12-14 01:44:12 +00:00
|
|
|
if (XR_FAILED(result)) {
|
2022-12-29 05:34:25 +00:00
|
|
|
print_line("OpenXR: Failed to create vulkan instance [", OpenXRAPI::get_singleton()->get_error_string(result), "]");
|
2021-12-14 01:44:12 +00:00
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ERR_FAIL_COND_V_MSG(vk_result == VK_ERROR_INCOMPATIBLE_DRIVER, false,
|
|
|
|
|
"Cannot find a compatible Vulkan installable client driver (ICD).\n\n"
|
|
|
|
|
"vkCreateInstance Failure");
|
|
|
|
|
ERR_FAIL_COND_V_MSG(vk_result == VK_ERROR_EXTENSION_NOT_PRESENT, false,
|
|
|
|
|
"Cannot find a specified extension library.\n"
|
|
|
|
|
"Make sure your layers path is set appropriately.\n"
|
|
|
|
|
"vkCreateInstance Failure");
|
|
|
|
|
ERR_FAIL_COND_V_MSG(vk_result, false,
|
|
|
|
|
"vkCreateInstance failed.\n\n"
|
|
|
|
|
"Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
|
|
|
|
|
"Please look at the Getting Started guide for additional information.\n"
|
|
|
|
|
"vkCreateInstance Failure");
|
|
|
|
|
|
|
|
|
|
*r_instance = vulkan_instance;
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool OpenXRVulkanExtension::get_physical_device(VkPhysicalDevice *r_device) {
|
2022-12-29 05:34:25 +00:00
|
|
|
ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), false);
|
2021-12-14 01:44:12 +00:00
|
|
|
|
|
|
|
|
XrVulkanGraphicsDeviceGetInfoKHR get_info = {
|
|
|
|
|
XR_TYPE_VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR, // type
|
|
|
|
|
nullptr, // next
|
2022-12-29 05:34:25 +00:00
|
|
|
OpenXRAPI::get_singleton()->get_system_id(), // systemId
|
2021-12-14 01:44:12 +00:00
|
|
|
vulkan_instance, // vulkanInstance
|
|
|
|
|
};
|
|
|
|
|
|
2022-12-29 05:34:25 +00:00
|
|
|
XrResult result = xrGetVulkanGraphicsDevice2KHR(OpenXRAPI::get_singleton()->get_instance(), &get_info, &vulkan_physical_device);
|
2021-12-14 01:44:12 +00:00
|
|
|
if (XR_FAILED(result)) {
|
2022-12-29 05:34:25 +00:00
|
|
|
print_line("OpenXR: Failed to obtain vulkan physical device [", OpenXRAPI::get_singleton()->get_error_string(result), "]");
|
2021-12-14 01:44:12 +00:00
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*r_device = vulkan_physical_device;
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool OpenXRVulkanExtension::create_vulkan_device(const VkDeviceCreateInfo *p_device_create_info, VkDevice *r_device) {
|
2022-12-29 05:34:25 +00:00
|
|
|
ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), false);
|
2021-12-14 01:44:12 +00:00
|
|
|
|
|
|
|
|
// the first entry in our queue list should be the one we need to remember...
|
|
|
|
|
vulkan_queue_family_index = p_device_create_info->pQueueCreateInfos[0].queueFamilyIndex;
|
|
|
|
|
vulkan_queue_index = 0; // ??
|
|
|
|
|
|
|
|
|
|
XrVulkanDeviceCreateInfoKHR create_info = {
|
|
|
|
|
XR_TYPE_VULKAN_DEVICE_CREATE_INFO_KHR, // type
|
|
|
|
|
nullptr, // next
|
2022-12-29 05:34:25 +00:00
|
|
|
OpenXRAPI::get_singleton()->get_system_id(), // systemId
|
2021-12-14 01:44:12 +00:00
|
|
|
0, // createFlags
|
|
|
|
|
vkGetInstanceProcAddr, // pfnGetInstanceProcAddr
|
|
|
|
|
vulkan_physical_device, // vulkanPhysicalDevice
|
|
|
|
|
p_device_create_info, // vulkanCreateInfo
|
|
|
|
|
nullptr // vulkanAllocator
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
VkResult vk_result = VK_SUCCESS;
|
2022-12-29 05:34:25 +00:00
|
|
|
XrResult result = xrCreateVulkanDeviceKHR(OpenXRAPI::get_singleton()->get_instance(), &create_info, &vulkan_device, &vk_result);
|
2021-12-14 01:44:12 +00:00
|
|
|
if (XR_FAILED(result)) {
|
2022-12-29 05:34:25 +00:00
|
|
|
print_line("OpenXR: Failed to create vulkan device [", OpenXRAPI::get_singleton()->get_error_string(result), "]");
|
2021-12-14 01:44:12 +00:00
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (vk_result != VK_SUCCESS) {
|
|
|
|
|
print_line("OpenXR: Failed to create vulkan device [vulkan error", vk_result, "]");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*r_device = vulkan_device;
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
XrGraphicsBindingVulkanKHR OpenXRVulkanExtension::graphics_binding_vulkan;
|
|
|
|
|
|
|
|
|
|
void *OpenXRVulkanExtension::set_session_create_and_get_next_pointer(void *p_next_pointer) {
|
|
|
|
|
graphics_binding_vulkan.type = XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR;
|
|
|
|
|
graphics_binding_vulkan.next = p_next_pointer;
|
|
|
|
|
graphics_binding_vulkan.instance = vulkan_instance;
|
|
|
|
|
graphics_binding_vulkan.physicalDevice = vulkan_physical_device;
|
|
|
|
|
graphics_binding_vulkan.device = vulkan_device;
|
|
|
|
|
graphics_binding_vulkan.queueFamilyIndex = vulkan_queue_family_index;
|
|
|
|
|
graphics_binding_vulkan.queueIndex = vulkan_queue_index;
|
|
|
|
|
|
|
|
|
|
return &graphics_binding_vulkan;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void OpenXRVulkanExtension::get_usable_swapchain_formats(Vector<int64_t> &p_usable_swap_chains) {
|
|
|
|
|
// We might want to do more here especially if we keep things in linear color space
|
|
|
|
|
// Possibly add in R10G10B10A2 as an option if we're using the mobile renderer.
|
|
|
|
|
p_usable_swap_chains.push_back(VK_FORMAT_R8G8B8A8_SRGB);
|
|
|
|
|
p_usable_swap_chains.push_back(VK_FORMAT_B8G8R8A8_SRGB);
|
|
|
|
|
p_usable_swap_chains.push_back(VK_FORMAT_R8G8B8A8_UINT);
|
|
|
|
|
p_usable_swap_chains.push_back(VK_FORMAT_B8G8R8A8_UINT);
|
|
|
|
|
}
|
|
|
|
|
|
2022-09-01 08:10:53 +00:00
|
|
|
void OpenXRVulkanExtension::get_usable_depth_formats(Vector<int64_t> &p_usable_swap_chains) {
|
|
|
|
|
p_usable_swap_chains.push_back(VK_FORMAT_D24_UNORM_S8_UINT);
|
|
|
|
|
p_usable_swap_chains.push_back(VK_FORMAT_D32_SFLOAT_S8_UINT);
|
2023-06-22 09:03:08 +00:00
|
|
|
p_usable_swap_chains.push_back(VK_FORMAT_D32_SFLOAT);
|
2022-09-01 08:10:53 +00:00
|
|
|
}
|
|
|
|
|
|
2021-12-14 01:44:12 +00:00
|
|
|
bool OpenXRVulkanExtension::get_swapchain_image_data(XrSwapchain p_swapchain, int64_t p_swapchain_format, uint32_t p_width, uint32_t p_height, uint32_t p_sample_count, uint32_t p_array_size, void **r_swapchain_graphics_data) {
|
|
|
|
|
XrSwapchainImageVulkanKHR *images = nullptr;
|
|
|
|
|
|
|
|
|
|
RenderingServer *rendering_server = RenderingServer::get_singleton();
|
|
|
|
|
ERR_FAIL_NULL_V(rendering_server, false);
|
|
|
|
|
RenderingDevice *rendering_device = rendering_server->get_rendering_device();
|
|
|
|
|
ERR_FAIL_NULL_V(rendering_device, false);
|
|
|
|
|
|
|
|
|
|
uint32_t swapchain_length;
|
|
|
|
|
XrResult result = xrEnumerateSwapchainImages(p_swapchain, 0, &swapchain_length, nullptr);
|
|
|
|
|
if (XR_FAILED(result)) {
|
2022-12-29 05:34:25 +00:00
|
|
|
print_line("OpenXR: Failed to get swapchaim image count [", OpenXRAPI::get_singleton()->get_error_string(result), "]");
|
2021-12-14 01:44:12 +00:00
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
images = (XrSwapchainImageVulkanKHR *)memalloc(sizeof(XrSwapchainImageVulkanKHR) * swapchain_length);
|
|
|
|
|
ERR_FAIL_NULL_V_MSG(images, false, "OpenXR Couldn't allocate memory for swap chain image");
|
|
|
|
|
|
|
|
|
|
for (uint64_t i = 0; i < swapchain_length; i++) {
|
|
|
|
|
images[i].type = XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR;
|
|
|
|
|
images[i].next = nullptr;
|
2022-02-27 10:13:02 +00:00
|
|
|
images[i].image = VK_NULL_HANDLE;
|
2021-12-14 01:44:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
result = xrEnumerateSwapchainImages(p_swapchain, swapchain_length, &swapchain_length, (XrSwapchainImageBaseHeader *)images);
|
|
|
|
|
if (XR_FAILED(result)) {
|
2022-12-29 05:34:25 +00:00
|
|
|
print_line("OpenXR: Failed to get swapchaim images [", OpenXRAPI::get_singleton()->get_error_string(result), "]");
|
2021-12-14 01:44:12 +00:00
|
|
|
memfree(images);
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// SwapchainGraphicsData *data = (SwapchainGraphicsData *)memalloc(sizeof(SwapchainGraphicsData));
|
|
|
|
|
SwapchainGraphicsData *data = memnew(SwapchainGraphicsData);
|
|
|
|
|
if (data == nullptr) {
|
|
|
|
|
print_line("OpenXR: Failed to allocate memory for swapchain data");
|
|
|
|
|
memfree(images);
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
*r_swapchain_graphics_data = data;
|
|
|
|
|
data->is_multiview = (p_array_size > 1);
|
|
|
|
|
|
2022-02-28 01:56:31 +00:00
|
|
|
RenderingDevice::DataFormat format = RenderingDevice::DATA_FORMAT_R8G8B8A8_SRGB;
|
|
|
|
|
RenderingDevice::TextureSamples samples = RenderingDevice::TEXTURE_SAMPLES_1;
|
2022-09-01 08:10:53 +00:00
|
|
|
uint64_t usage_flags = RenderingDevice::TEXTURE_USAGE_SAMPLING_BIT;
|
2021-12-14 01:44:12 +00:00
|
|
|
|
2022-02-28 01:56:31 +00:00
|
|
|
switch (p_swapchain_format) {
|
|
|
|
|
case VK_FORMAT_R8G8B8A8_SRGB:
|
|
|
|
|
// Even though this is an sRGB framebuffer format we're using UNORM here.
|
|
|
|
|
// The reason here is because Godot does a linear to sRGB conversion while
|
|
|
|
|
// with the sRGB format, this conversion would be doubled by the hardware.
|
|
|
|
|
// This also means we're reading the values as is for our preview on screen.
|
|
|
|
|
// The OpenXR runtime however is still treating this as an sRGB format and
|
|
|
|
|
// will thus do an sRGB -> Linear conversion as expected.
|
|
|
|
|
// format = RenderingDevice::DATA_FORMAT_R8G8B8A8_SRGB;
|
|
|
|
|
format = RenderingDevice::DATA_FORMAT_R8G8B8A8_UNORM;
|
2022-09-01 08:10:53 +00:00
|
|
|
usage_flags |= RenderingDevice::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
|
2022-02-28 01:56:31 +00:00
|
|
|
break;
|
|
|
|
|
case VK_FORMAT_B8G8R8A8_SRGB:
|
|
|
|
|
// format = RenderingDevice::DATA_FORMAT_B8G8R8A8_SRGB;
|
|
|
|
|
format = RenderingDevice::DATA_FORMAT_B8G8R8A8_UNORM;
|
2022-09-01 08:10:53 +00:00
|
|
|
usage_flags |= RenderingDevice::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
|
2022-02-28 01:56:31 +00:00
|
|
|
break;
|
|
|
|
|
case VK_FORMAT_R8G8B8A8_UINT:
|
|
|
|
|
format = RenderingDevice::DATA_FORMAT_R8G8B8A8_UINT;
|
2022-09-01 08:10:53 +00:00
|
|
|
usage_flags |= RenderingDevice::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
|
2022-02-28 01:56:31 +00:00
|
|
|
break;
|
|
|
|
|
case VK_FORMAT_B8G8R8A8_UINT:
|
|
|
|
|
format = RenderingDevice::DATA_FORMAT_B8G8R8A8_UINT;
|
2022-09-01 08:10:53 +00:00
|
|
|
usage_flags |= RenderingDevice::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
|
|
|
|
|
break;
|
2023-06-22 09:03:08 +00:00
|
|
|
case VK_FORMAT_D32_SFLOAT:
|
|
|
|
|
format = RenderingDevice::DATA_FORMAT_D32_SFLOAT;
|
2022-09-01 08:10:53 +00:00
|
|
|
usage_flags |= RenderingDevice::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
|
|
|
|
|
break;
|
|
|
|
|
case VK_FORMAT_D24_UNORM_S8_UINT:
|
|
|
|
|
format = RenderingDevice::DATA_FORMAT_D24_UNORM_S8_UINT;
|
|
|
|
|
usage_flags |= RenderingDevice::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
|
|
|
|
|
break;
|
|
|
|
|
case VK_FORMAT_D32_SFLOAT_S8_UINT:
|
|
|
|
|
format = RenderingDevice::DATA_FORMAT_D32_SFLOAT_S8_UINT;
|
|
|
|
|
usage_flags |= RenderingDevice::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
|
2022-02-28 01:56:31 +00:00
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
// continue with our default value
|
|
|
|
|
print_line("Unsupported swapchain format ", p_swapchain_format);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch (p_sample_count) {
|
|
|
|
|
case 1:
|
|
|
|
|
samples = RenderingDevice::TEXTURE_SAMPLES_1;
|
|
|
|
|
break;
|
|
|
|
|
case 2:
|
|
|
|
|
samples = RenderingDevice::TEXTURE_SAMPLES_2;
|
|
|
|
|
break;
|
|
|
|
|
case 4:
|
|
|
|
|
samples = RenderingDevice::TEXTURE_SAMPLES_4;
|
|
|
|
|
break;
|
|
|
|
|
case 8:
|
|
|
|
|
samples = RenderingDevice::TEXTURE_SAMPLES_8;
|
|
|
|
|
break;
|
|
|
|
|
case 16:
|
|
|
|
|
samples = RenderingDevice::TEXTURE_SAMPLES_16;
|
|
|
|
|
break;
|
|
|
|
|
case 32:
|
|
|
|
|
samples = RenderingDevice::TEXTURE_SAMPLES_32;
|
|
|
|
|
break;
|
|
|
|
|
case 64:
|
|
|
|
|
samples = RenderingDevice::TEXTURE_SAMPLES_64;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
// continue with our default value
|
|
|
|
|
print_line("Unsupported sample count ", p_sample_count);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2022-09-01 08:10:53 +00:00
|
|
|
Vector<RID> texture_rids;
|
2021-12-14 01:44:12 +00:00
|
|
|
|
|
|
|
|
// create Godot texture objects for each entry in our swapchain
|
|
|
|
|
for (uint64_t i = 0; i < swapchain_length; i++) {
|
|
|
|
|
RID image_rid = rendering_device->texture_create_from_extension(
|
|
|
|
|
p_array_size == 1 ? RenderingDevice::TEXTURE_TYPE_2D : RenderingDevice::TEXTURE_TYPE_2D_ARRAY,
|
|
|
|
|
format,
|
|
|
|
|
samples,
|
|
|
|
|
usage_flags,
|
|
|
|
|
(uint64_t)images[i].image,
|
|
|
|
|
p_width,
|
|
|
|
|
p_height,
|
|
|
|
|
1,
|
|
|
|
|
p_array_size);
|
|
|
|
|
|
2022-09-01 08:10:53 +00:00
|
|
|
texture_rids.push_back(image_rid);
|
2021-12-14 01:44:12 +00:00
|
|
|
}
|
|
|
|
|
|
2022-09-01 08:10:53 +00:00
|
|
|
data->texture_rids = texture_rids;
|
2021-12-14 01:44:12 +00:00
|
|
|
|
|
|
|
|
memfree(images);
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
Implement Vector4, Vector4i, Projection
Implement built-in classes Vector4, Vector4i and Projection.
* Two versions of Vector4 (float and integer).
* A Projection class, which is a 4x4 matrix specialized in projection types.
These types have been requested for a long time, but given they were very corner case they were not added before.
Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity.
**Q**: Why Projection and not Matrix4?
**A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
|
|
|
bool OpenXRVulkanExtension::create_projection_fov(const XrFovf p_fov, double p_z_near, double p_z_far, Projection &r_camera_matrix) {
|
2021-12-14 01:44:12 +00:00
|
|
|
// Even though this is a Vulkan renderer we're using OpenGL coordinate systems
|
2023-02-16 13:47:31 +00:00
|
|
|
OpenXRUtil::XrMatrix4x4f matrix;
|
|
|
|
|
OpenXRUtil::XrMatrix4x4f_CreateProjectionFov(&matrix, OpenXRUtil::GRAPHICS_OPENGL, p_fov, (float)p_z_near, (float)p_z_far);
|
2021-12-14 01:44:12 +00:00
|
|
|
|
|
|
|
|
for (int j = 0; j < 4; j++) {
|
|
|
|
|
for (int i = 0; i < 4; i++) {
|
2022-10-04 16:44:48 +00:00
|
|
|
r_camera_matrix.columns[j][i] = matrix.m[j * 4 + i];
|
2021-12-14 01:44:12 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2022-09-01 08:10:53 +00:00
|
|
|
RID OpenXRVulkanExtension::get_texture(void *p_swapchain_graphics_data, int p_image_index) {
|
2021-12-14 01:44:12 +00:00
|
|
|
SwapchainGraphicsData *data = (SwapchainGraphicsData *)p_swapchain_graphics_data;
|
2022-09-01 08:10:53 +00:00
|
|
|
ERR_FAIL_NULL_V(data, RID());
|
2021-12-14 01:44:12 +00:00
|
|
|
|
2022-09-01 08:10:53 +00:00
|
|
|
ERR_FAIL_INDEX_V(p_image_index, data->texture_rids.size(), RID());
|
|
|
|
|
return data->texture_rids[p_image_index];
|
2021-12-14 01:44:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void OpenXRVulkanExtension::cleanup_swapchain_graphics_data(void **p_swapchain_graphics_data) {
|
|
|
|
|
if (*p_swapchain_graphics_data == nullptr) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
SwapchainGraphicsData *data = (SwapchainGraphicsData *)*p_swapchain_graphics_data;
|
|
|
|
|
|
|
|
|
|
RenderingServer *rendering_server = RenderingServer::get_singleton();
|
|
|
|
|
ERR_FAIL_NULL(rendering_server);
|
|
|
|
|
RenderingDevice *rendering_device = rendering_server->get_rendering_device();
|
|
|
|
|
ERR_FAIL_NULL(rendering_device);
|
|
|
|
|
|
2022-09-01 08:10:53 +00:00
|
|
|
for (int i = 0; i < data->texture_rids.size(); i++) {
|
2021-12-14 01:44:12 +00:00
|
|
|
// This should clean up our RIDs and associated texture objects but shouldn't destroy the images, they are owned by our XrSwapchain
|
2022-09-01 08:10:53 +00:00
|
|
|
rendering_device->free(data->texture_rids[i]);
|
2021-12-14 01:44:12 +00:00
|
|
|
}
|
2022-09-01 08:10:53 +00:00
|
|
|
data->texture_rids.clear();
|
2021-12-14 01:44:12 +00:00
|
|
|
|
|
|
|
|
memdelete(data);
|
|
|
|
|
*p_swapchain_graphics_data = nullptr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define ENUM_TO_STRING_CASE(e) \
|
|
|
|
|
case e: { \
|
|
|
|
|
return String(#e); \
|
|
|
|
|
} break;
|
|
|
|
|
|
|
|
|
|
String OpenXRVulkanExtension::get_swapchain_format_name(int64_t p_swapchain_format) const {
|
|
|
|
|
// This really should be in vulkan_context...
|
|
|
|
|
VkFormat format = VkFormat(p_swapchain_format);
|
|
|
|
|
switch (format) {
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_UNDEFINED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R4G4_UNORM_PACK8)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R4G4B4A4_UNORM_PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B4G4R4A4_UNORM_PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R5G6B5_UNORM_PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B5G6R5_UNORM_PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R5G5B5A1_UNORM_PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B5G5R5A1_UNORM_PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A1R5G5B5_UNORM_PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8_SNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8_USCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8_SSCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8_SINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8_SRGB)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8_SNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8_USCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8_SSCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8_SINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8_SRGB)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8B8_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8B8_SNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8B8_USCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8B8_SSCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8B8_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8B8_SINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8B8_SRGB)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B8G8R8_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B8G8R8_SNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B8G8R8_USCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B8G8R8_SSCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B8G8R8_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B8G8R8_SINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B8G8R8_SRGB)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8B8A8_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8B8A8_SNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8B8A8_USCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8B8A8_SSCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8B8A8_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8B8A8_SINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R8G8B8A8_SRGB)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B8G8R8A8_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B8G8R8A8_SNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B8G8R8A8_USCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B8G8R8A8_SSCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B8G8R8A8_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B8G8R8A8_SINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B8G8R8A8_SRGB)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A8B8G8R8_UNORM_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A8B8G8R8_SNORM_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A8B8G8R8_USCALED_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A8B8G8R8_SSCALED_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A8B8G8R8_UINT_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A8B8G8R8_SINT_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A8B8G8R8_SRGB_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A2R10G10B10_UNORM_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A2R10G10B10_SNORM_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A2R10G10B10_USCALED_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A2R10G10B10_SSCALED_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A2R10G10B10_UINT_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A2R10G10B10_SINT_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A2B10G10R10_UNORM_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A2B10G10R10_SNORM_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A2B10G10R10_USCALED_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A2B10G10R10_SSCALED_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A2B10G10R10_UINT_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A2B10G10R10_SINT_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16_SNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16_USCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16_SSCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16_SINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16_SFLOAT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16_SNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16_USCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16_SSCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16_SINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16_SFLOAT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16B16_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16B16_SNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16B16_USCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16B16_SSCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16B16_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16B16_SINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16B16_SFLOAT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16B16A16_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16B16A16_SNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16B16A16_USCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16B16A16_SSCALED)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16B16A16_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16B16A16_SINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R16G16B16A16_SFLOAT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R32_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R32_SINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R32_SFLOAT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R32G32_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R32G32_SINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R32G32_SFLOAT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R32G32B32_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R32G32B32_SINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R32G32B32_SFLOAT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R32G32B32A32_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R32G32B32A32_SINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R32G32B32A32_SFLOAT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R64_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R64_SINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R64_SFLOAT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R64G64_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R64G64_SINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R64G64_SFLOAT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R64G64B64_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R64G64B64_SINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R64G64B64_SFLOAT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R64G64B64A64_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R64G64B64A64_SINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R64G64B64A64_SFLOAT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B10G11R11_UFLOAT_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_E5B9G9R9_UFLOAT_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_D16_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_X8_D24_UNORM_PACK32)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_D32_SFLOAT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_S8_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_D16_UNORM_S8_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_D24_UNORM_S8_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_D32_SFLOAT_S8_UINT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_BC1_RGB_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_BC1_RGB_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_BC1_RGBA_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_BC1_RGBA_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_BC2_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_BC2_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_BC3_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_BC3_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_BC4_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_BC4_SNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_BC5_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_BC5_SNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_BC6H_UFLOAT_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_BC6H_SFLOAT_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_BC7_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_BC7_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_EAC_R11_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_EAC_R11_SNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_EAC_R11G11_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_EAC_R11G11_SNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_4x4_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_4x4_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_5x4_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_5x4_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_5x5_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_5x5_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_6x5_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_6x5_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_6x6_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_6x6_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_8x5_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_8x5_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_8x6_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_8x6_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_8x8_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_8x8_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_10x5_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_10x5_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_10x6_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_10x6_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_10x8_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_10x8_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_10x10_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_10x10_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_12x10_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_12x10_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_12x12_UNORM_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_12x12_SRGB_BLOCK)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G8B8G8R8_422_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B8G8R8G8_422_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G8_B8R8_2PLANE_420_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G8_B8R8_2PLANE_422_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R10X6_UNORM_PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R10X6G10X6_UNORM_2PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R12X4_UNORM_PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R12X4G12X4_UNORM_2PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G16B16G16R16_422_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_B16G16R16G16_422_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G16_B16R16_2PLANE_420_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT)
|
|
|
|
|
ENUM_TO_STRING_CASE(VK_FORMAT_MAX_ENUM)
|
|
|
|
|
default: {
|
|
|
|
|
return String("Swapchain format ") + String::num_int64(int64_t(p_swapchain_format));
|
|
|
|
|
} break;
|
|
|
|
|
}
|
|
|
|
|
}
|
