/* * WiVRn VR streaming * Copyright (C) 2022 Guillaume Meunier * Copyright (C) 2022 Patrick Nicolas * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include "instance.h" #include "application.h" #include "xr/details/enumerate.h" #include "xr/htc_exts.h" #include "xr/to_string.h" #include #include #include #include #include #include #include #include #include #include static XrBool32 debug_callback( XrDebugUtilsMessageSeverityFlagsEXT messageSeverity, XrDebugUtilsMessageTypeFlagsEXT messageTypes, const XrDebugUtilsMessengerCallbackDataEXT * callbackData, void * userData) { spdlog::info("OpenXR debug message: severity={}, type={}, function={}, {}", messageSeverity, messageTypes, callbackData->functionName, callbackData->message); return XR_FALSE; } namespace { struct version_info { std::set> promoted_extensions; std::set> removed_extensions; bool shall_request(std::string_view extension) const { return not(promoted_extensions.contains(extension) or removed_extensions.contains(extension)); } static const std::map versions; static const version_info * get(XrVersion version) { auto it = versions.find(XR_MAKE_VERSION(XR_VERSION_MAJOR(version), XR_VERSION_MINOR(version), 0)); if (it == versions.end()) return nullptr; return &it->second; } }; const std::map version_info::versions = {{ XR_MAKE_VERSION(1, 1, 0), { .promoted_extensions = { XR_KHR_LOCATE_SPACES_EXTENSION_NAME, XR_KHR_MAINTENANCE1_EXTENSION_NAME, XR_EXT_HP_MIXED_REALITY_CONTROLLER_EXTENSION_NAME, XR_EXT_LOCAL_FLOOR_EXTENSION_NAME, XR_EXT_PALM_POSE_EXTENSION_NAME, XR_EXT_SAMSUNG_ODYSSEY_CONTROLLER_EXTENSION_NAME, XR_EXT_UUID_EXTENSION_NAME, XR_BD_CONTROLLER_INTERACTION_EXTENSION_NAME, XR_HTC_VIVE_COSMOS_CONTROLLER_INTERACTION_EXTENSION_NAME, XR_HTC_VIVE_FOCUS3_CONTROLLER_INTERACTION_EXTENSION_NAME, XR_ML_ML2_CONTROLLER_INTERACTION_EXTENSION_NAME, XR_VARJO_QUAD_VIEWS_EXTENSION_NAME, }, .removed_extensions = { // Extensions that are included, but actually different XR_FB_TOUCH_CONTROLLER_PRO_EXTENSION_NAME, XR_META_TOUCH_CONTROLLER_PLUS_EXTENSION_NAME, }, }, }}; } // namespace static std::pair create_instance(XrInstanceCreateInfo & info, std::vector & in_extensions) { XrResult res = XR_ERROR_API_VERSION_UNSUPPORTED; for (XrVersion version: { XR_API_VERSION_1_1, XR_API_VERSION_1_0, }) { if (version > application::get_hmd_traits().max_openxr_api_version) { spdlog::info("skip OpenXR {} due to headset quirk max version {}", xr::to_string(version), xr::to_string(application::get_hmd_traits().max_openxr_api_version)); continue; } std::vector extensions; info.applicationInfo.apiVersion = version; auto v_info = version_info::get(version); if (v_info) { std::ranges::copy_if( in_extensions, std::back_inserter(extensions), [v_info](const char * ext) { return v_info->shall_request(ext); }); info.enabledExtensionNames = extensions.data(); info.enabledExtensionCount = extensions.size(); } else { info.enabledExtensionNames = in_extensions.data(); info.enabledExtensionCount = in_extensions.size(); } XrInstance inst; res = xrCreateInstance(&info, &inst); if (XR_SUCCEEDED(res)) { if (v_info) { extensions.insert(extensions.end(), v_info->promoted_extensions.begin(), v_info->promoted_extensions.end()); std::swap(in_extensions, extensions); } return {version, inst}; } spdlog::info("Failed to create OpenXR instance version {}: {}", xr::to_string(version), xr::to_string(res)); } throw std::system_error(res, xr::error_category(), "Failed to create OpenXR instance"); } #if defined(XR_USE_PLATFORM_ANDROID) xr::instance::instance(std::string_view application_name, void * applicationVM, void * applicationActivity, std::vector extensions) #else xr::instance::instance(std::string_view application_name, std::vector extensions) #endif { #if defined(XR_USE_GRAPHICS_API_VULKAN) extensions.push_back(XR_KHR_VULKAN_ENABLE2_EXTENSION_NAME); #else #error Not implemented #endif #if defined(XR_USE_PLATFORM_ANDROID) extensions.push_back(XR_KHR_ANDROID_CREATE_INSTANCE_EXTENSION_NAME); #endif #if defined(XR_USE_PLATFORM_ANDROID) // OpenXR spec, XR_KHR_loader_init_android: // On Android, some loader implementations need the application to provide // additional information on initialization. This extension defines the // parameters needed by such implementations. If this is available on a // given implementation, an application must make use of it. // This must be called before the instance is created PFN_xrInitializeLoaderKHR initializeLoader = nullptr; if (XR_SUCCEEDED(xrGetInstanceProcAddr(XR_NULL_HANDLE, "xrInitializeLoaderKHR", (PFN_xrVoidFunction *)(&initializeLoader)))) { XrLoaderInitInfoAndroidKHR loaderInitInfoAndroid = { .type = XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR, .applicationVM = applicationVM, .applicationContext = applicationActivity, }; initializeLoader((const XrLoaderInitInfoBaseHeaderKHR *)&loaderInitInfoAndroid); } #endif std::vector layers; // TODO: runtime switch spdlog::info("Available OpenXR layers:"); for (XrApiLayerProperties & i: xr::details::enumerate(xrEnumerateApiLayerProperties)) { spdlog::info(" {}", i.layerName); #ifndef NDEBUG if (!strcmp(i.layerName, "XR_APILAYER_LUNARG_core_validation")) { layers.push_back("XR_APILAYER_LUNARG_core_validation"); } #endif } spdlog::info("Available OpenXR extensions:"); bool debug_utils_found = false; auto all_extensions = xr::instance::extensions(); std::ranges::sort(all_extensions, [](const char * a, const char * b) { return strcmp(a, b) < 0; }, &XrExtensionProperties::extensionName); for (XrExtensionProperties & i: all_extensions) { if (application::get_hmd_traits().blacklisted_extensions.contains(i.extensionName)) spdlog::info(" {} (version {}) (blacklisted)", i.extensionName, i.extensionVersion); else spdlog::info(" {} (version {})", i.extensionName, i.extensionVersion); #ifndef NDEBUG if (!strcmp(i.extensionName, "XR_EXT_debug_utils")) { debug_utils_found = true; extensions.push_back("XR_EXT_debug_utils"); } #endif } XrInstanceCreateInfo create_info{ .type = XR_TYPE_INSTANCE_CREATE_INFO, .enabledApiLayerCount = (uint32_t)layers.size(), .enabledApiLayerNames = layers.data(), .enabledExtensionCount = (uint32_t)extensions.size(), .enabledExtensionNames = extensions.data(), }; strncpy(create_info.applicationInfo.applicationName, application_name.data(), sizeof(create_info.applicationInfo.applicationName) - 1); #if defined(XR_USE_PLATFORM_ANDROID) XrInstanceCreateInfoAndroidKHR instanceCreateInfoAndroid{ .type = XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR, .applicationVM = applicationVM, .applicationActivity = applicationActivity, }; create_info.next = &instanceCreateInfoAndroid; #endif std::tie(api_version, id) = create_instance(create_info, extensions); spdlog::info("Using OpenXR extensions:"); for (auto i: extensions) { uint32_t version = 0; for (auto & j: all_extensions) { if (!strcmp(j.extensionName, i)) version = j.extensionVersion; } loaded_extensions.emplace(i, version); spdlog::info(" {}", i); } if (debug_utils_found) { XrDebugUtilsMessengerCreateInfoEXT debug_messenger_info{ .type = XR_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, .messageSeverities = XR_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | XR_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT | XR_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | XR_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT, .messageTypes = XR_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | XR_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT | XR_DEBUG_UTILS_MESSAGE_TYPE_CONFORMANCE_BIT_EXT, .userCallback = debug_callback}; auto xrCreateDebugUtilsMessengerEXT = get_proc("xrCreateDebugUtilsMessengerEXT"); XrDebugUtilsMessengerEXT messenger; CHECK_XR(xrCreateDebugUtilsMessengerEXT(id, &debug_messenger_info, &messenger)); } XrInstanceProperties prop{XR_TYPE_INSTANCE_PROPERTIES}; CHECK_XR(xrGetInstanceProperties(id, &prop)); // TODO: exception safety // if (!XR_SUCCEEDED(result)) // { // xrDestroyInstance(id); // throw error("Cannot get instance properties", result); // } runtime_version = to_string(prop.runtimeVersion); runtime_name = prop.runtimeName; } std::string xr::instance::path_to_string(XrPath path) { if (path == XR_NULL_PATH) return "XR_NULL_PATH"; uint32_t length; std::string s; CHECK_XR(xrPathToString(id, path, 0, &length, nullptr)); s.resize(length - 1); // length includes the null terminator CHECK_XR(xrPathToString(id, path, length, &length, s.data())); assert(s[length - 1] == '\0'); return s; } XrPath xr::instance::string_to_path(const std::string & path) { XrPath p; CHECK_XR(xrStringToPath(id, path.c_str(), &p)); return p; } std::vector xr::instance::enumerate_paths_for_interaction_profile(XrPath interaction_profile, XrPath user_path) { assert(has_extension(XR_HTC_PATH_ENUMERATION_EXTENSION_NAME)); static auto xrEnumeratePathsForInteractionProfileHTC = get_proc("xrEnumeratePathsForInteractionProfileHTC"); XrPathsForInteractionProfileEnumerateInfoHTC profile_info{ .type = XR_TYPE_UNKNOWN, .next = nullptr, .interactionProfile = interaction_profile, .userPath = user_path, }; return xr::details::enumerate(xrEnumeratePathsForInteractionProfileHTC, id, profile_info); } bool xr::instance::poll_event(xr::event & buffer) { buffer.header.type = XR_TYPE_EVENT_DATA_BUFFER; buffer.header.next = nullptr; XrResult result = CHECK_XR(xrPollEvent(id, &buffer.header)); return result == XR_SUCCESS; } void xr::instance::suggest_bindings(const std::string & interaction_profile, std::vector & bindings) { XrInteractionProfileSuggestedBinding suggested_binding{ .type = XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING, .interactionProfile = string_to_path(interaction_profile), .countSuggestedBindings = (uint32_t)bindings.size(), .suggestedBindings = bindings.data(), }; CHECK_XR(xrSuggestInteractionProfileBindings(id, &suggested_binding)); } XrTime xr::instance::now() { static PFN_xrConvertTimespecTimeToTimeKHR xrConvertTimespecTimeToTimeKHR = get_proc("xrConvertTimespecTimeToTimeKHR"); timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); XrTime res; CHECK_XR(xrConvertTimespecTimeToTimeKHR(id, &ts, &res)); return res; } std::vector xr::instance::extensions(const char * layer_name) { return xr::details::enumerate(xrEnumerateInstanceExtensionProperties, layer_name); }