Files
WiVRn/client/application.cpp
T
Patrick Nicolas 347052109d Add device-specific logic
Controller bindings have been moved to the new logic.
Recommended view sizes are now overriden as recommendation is based on
the integrated GPU while for streaming headsets can usually do much
better.
2023-11-20 21:14:28 +01:00

995 lines
30 KiB
C++

/*
* WiVRn VR streaming
* Copyright (C) 2022 Guillaume Meunier <[email protected]>
* Copyright (C) 2022 Patrick Nicolas <[email protected]>
*
* 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 <https://www.gnu.org/licenses/>.
*/
#include "application.h"
#include "hardware.h"
#include "magic_enum.hpp"
#include "scene.h"
#include "spdlog/common.h"
#include "spdlog/spdlog.h"
#include "utils/ranges.h"
#include "vk/details/enumerate.h"
#include "vk/vk.h"
#include "xr/xr.h"
#include <algorithm>
#include <chrono>
#include <thread>
#include <vector>
#include <vulkan/vulkan.h>
#include <vulkan/vulkan_core.h>
#include <openxr/openxr_platform.h>
#ifndef NDEBUG
#include "utils/backtrace.h"
#endif
#ifdef XR_USE_PLATFORM_ANDROID
#include <android/native_activity.h>
#include <sys/system_properties.h>
#endif
using namespace std::chrono_literals;
application * application::instance_ = nullptr;
#ifdef XR_USE_PLATFORM_ANDROID
jni_thread::jni_thread(application & app) :
vm(app.app_info.native_app->activity->vm)
{
vm->AttachCurrentThread(&env, nullptr);
}
jni_thread::jni_thread() :
jni_thread(application::instance())
{
}
jni_thread::~jni_thread()
{
vm->DetachCurrentThread();
}
#endif
VkBool32 application::vulkan_debug_report_callback(
VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objectType,
uint64_t object,
size_t location,
int32_t messageCode,
const char * pLayerPrefix,
const char * pMessage,
void * pUserData)
{
if (instance_->debug_report_ignored_objects.contains(object))
return VK_FALSE;
spdlog::level::level_enum level = spdlog::level::info;
if (flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT)
{
level = spdlog::level::info;
}
else if (flags & (VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT))
{
level = spdlog::level::warn;
}
else if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT)
{
level = spdlog::level::err;
}
else if (flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT)
{
level = spdlog::level::debug;
}
// for(const std::string& s: utils::split(pMessage, "|"))
// spdlog::log(level, s);
spdlog::log(level, pMessage);
auto it = instance_->debug_report_object_name.find(object);
if (it != instance_->debug_report_object_name.end())
{
spdlog::log(level, "{:#016x}: {}", object, it->second);
}
#ifndef NDEBUG
if (level >= spdlog::level::warn)
{
bool validation_layer_found = false;
for (auto & i: utils::backtrace(20))
{
if (i.library == "libVkLayer_khronos_validation.so")
validation_layer_found = true;
if (validation_layer_found && i.library != "libVkLayer_khronos_validation.so")
spdlog::log(level, "{:#016x}: {} + {:#x}", i.pc, i.library, i.pc - i.library_base);
}
}
if (level >= spdlog::level::err)
abort();
#endif
return VK_FALSE;
}
void application::initialize_vulkan()
{
auto graphics_requirements = xr_system_id.graphics_requirements();
XrVersion vulkan_version = std::max(app_info.min_vulkan_version, graphics_requirements.minApiVersionSupported);
spdlog::info("OpenXR runtime wants Vulkan {}", xr::to_string(graphics_requirements.minApiVersionSupported));
spdlog::info("Requesting Vulkan {}", xr::to_string(vulkan_version));
std::vector<const char *> layers;
spdlog::info("Available Vulkan layers:");
bool validation_layer_found = false;
for (VkLayerProperties & i: vk::details::enumerate<VkLayerProperties>(vkEnumerateInstanceLayerProperties))
{
spdlog::info(" {}", i.layerName);
if (!strcmp(i.layerName, "VK_LAYER_KHRONOS_validation"))
{
validation_layer_found = true;
}
}
#ifndef NDEBUG
if (validation_layer_found)
{
spdlog::info("Using Vulkan validation layer");
layers.push_back("VK_LAYER_KHRONOS_validation");
}
#endif
std::vector<const char *> instance_extensions{};
std::vector<const char *> device_extensions{};
#ifndef NDEBUG
bool debug_report_found = false;
bool debug_utils_found = false;
#endif
spdlog::info("Available Vulkan instance extensions:");
for (VkExtensionProperties & i: vk::details::enumerate<VkExtensionProperties>(vkEnumerateInstanceExtensionProperties, nullptr))
{
spdlog::info(" {}", i.extensionName);
#ifndef NDEBUG
if (!strcmp(i.extensionName, VK_EXT_DEBUG_REPORT_EXTENSION_NAME))
debug_report_found = true;
if (!strcmp(i.extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME))
debug_utils_found = true;
#endif
}
#ifndef NDEBUG
if (debug_utils_found && debug_report_found)
{
// debug_extensions_found = true;
// spdlog::info("Using debug extensions");
instance_extensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
// instance_extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
}
#endif
#ifdef XR_USE_PLATFORM_ANDROID
device_extensions.push_back(VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME);
device_extensions.push_back(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME);
device_extensions.push_back(VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME);
device_extensions.push_back(VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME);
device_extensions.push_back(VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME);
device_extensions.push_back(VK_KHR_MAINTENANCE1_EXTENSION_NAME);
device_extensions.push_back(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME);
device_extensions.push_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
instance_extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
instance_extensions.push_back(VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME);
#endif
VkApplicationInfo applicationInfo{};
applicationInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
applicationInfo.apiVersion = VK_MAKE_API_VERSION(0, XR_VERSION_MAJOR(vulkan_version), XR_VERSION_MINOR(vulkan_version), 0);
applicationInfo.pApplicationName = app_info.name.c_str();
applicationInfo.applicationVersion = app_info.version;
applicationInfo.pEngineName = engine_name;
applicationInfo.engineVersion = engine_version;
VkInstanceCreateInfo instanceCreateInfo{};
instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceCreateInfo.pApplicationInfo = &applicationInfo;
instanceCreateInfo.enabledLayerCount = layers.size();
instanceCreateInfo.ppEnabledLayerNames = layers.data();
instanceCreateInfo.enabledExtensionCount = instance_extensions.size();
instanceCreateInfo.ppEnabledExtensionNames = instance_extensions.data();
XrVulkanInstanceCreateInfoKHR create_info{};
create_info.type = XR_TYPE_VULKAN_INSTANCE_CREATE_INFO_KHR;
create_info.systemId = xr_system_id;
create_info.createFlags = 0;
create_info.pfnGetInstanceProcAddr = vkGetInstanceProcAddr;
create_info.vulkanCreateInfo = &instanceCreateInfo;
create_info.vulkanAllocator = nullptr;
auto xrCreateVulkanInstanceKHR =
xr_instance.get_proc<PFN_xrCreateVulkanInstanceKHR>("xrCreateVulkanInstanceKHR");
VkResult vresult;
XrResult xresult = xrCreateVulkanInstanceKHR(xr_instance, &create_info, &vk_instance, &vresult);
CHECK_VK(vresult, "xrCreateVulkanInstanceKHR");
CHECK_XR(xresult, "xrCreateVulkanInstanceKHR");
#ifndef NDEBUG
if (debug_report_found)
{
VkDebugReportCallbackCreateInfoEXT debug_report_info{
.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
.flags = VK_DEBUG_REPORT_INFORMATION_BIT_EXT |
VK_DEBUG_REPORT_WARNING_BIT_EXT |
VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT |
VK_DEBUG_REPORT_ERROR_BIT_EXT |
VK_DEBUG_REPORT_DEBUG_BIT_EXT,
.pfnCallback = vulkan_debug_report_callback,
};
VkDebugReportCallbackEXT debug_report_callback;
auto vkCreateDebugReportCallbackEXT = get_vulkan_proc<PFN_vkCreateDebugReportCallbackEXT>("vkCreateDebugReportCallbackEXT");
CHECK_VK(vkCreateDebugReportCallbackEXT(vk_instance, &debug_report_info, nullptr, &debug_report_callback));
}
#endif
vk_physical_device = xr_system_id.physical_device(vk_instance);
spdlog::info("Available Vulkan device extensions:");
for (VkExtensionProperties & i: vk::details::enumerate<VkExtensionProperties>(vkEnumerateDeviceExtensionProperties, vk_physical_device, nullptr))
{
spdlog::info(" {}", i.extensionName);
}
VkPhysicalDeviceProperties prop;
vkGetPhysicalDeviceProperties(vk_physical_device, &prop);
spdlog::info("Initializing Vulkan with device {}", prop.deviceName);
uint32_t count;
vkGetPhysicalDeviceQueueFamilyProperties(vk_physical_device, &count, nullptr);
std::vector<VkQueueFamilyProperties> queue_properties(count);
vkGetPhysicalDeviceQueueFamilyProperties(vk_physical_device, &count, queue_properties.data());
vk_queue_family_index = -1;
[[maybe_unused]] bool vk_queue_found = false;
for (size_t i = 0; i < queue_properties.size(); i++)
{
if (queue_properties[i].queueFlags & VkQueueFlagBits::VK_QUEUE_GRAPHICS_BIT)
{
vk_queue_found = true;
vk_queue_family_index = i;
break;
}
}
assert(vk_queue_found);
spdlog::info("Using queue family {}", vk_queue_family_index);
float queuePriority = 0.0f;
VkDeviceQueueCreateInfo queueCreateInfo{};
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo.queueFamilyIndex = vk_queue_family_index;
queueCreateInfo.queueCount = 1;
queueCreateInfo.pQueuePriorities = &queuePriority;
VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR ycbcr_feature{
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR,
.samplerYcbcrConversion = VK_TRUE};
VkPhysicalDeviceFeatures deviceFeatures{};
VkDeviceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
createInfo.pNext = &ycbcr_feature;
createInfo.pQueueCreateInfos = &queueCreateInfo;
createInfo.queueCreateInfoCount = 1;
createInfo.pEnabledFeatures = &deviceFeatures;
createInfo.enabledExtensionCount = device_extensions.size();
createInfo.ppEnabledExtensionNames = device_extensions.data();
vk_device = xr_system_id.create_device(vk_physical_device, createInfo);
vkGetDeviceQueue(vk_device, vk_queue_family_index, 0, &vk_queue);
}
void application::log_views()
{
for (XrViewConfigurationType i: xr_system_id.view_configurations())
{
spdlog::info("View configuration {}", xr::to_string(i));
XrViewConfigurationProperties p = xr_system_id.view_configuration_properties(i);
spdlog::info(" fovMutable: {}", p.fovMutable ? "true" : "false");
int n = 0;
for (const XrViewConfigurationView & j: xr_system_id.view_configuration_views(i))
{
spdlog::info(" View {}:", ++n);
spdlog::info(" Recommended: {}x{}, {} sample(s)", j.recommendedImageRectWidth, j.recommendedImageRectHeight, j.recommendedSwapchainSampleCount);
spdlog::info(" Maximum: {}x{}, {} sample(s)", j.maxImageRectWidth, j.maxImageRectHeight, j.maxSwapchainSampleCount);
}
for (const XrEnvironmentBlendMode j: xr_system_id.environment_blend_modes(i))
{
spdlog::info(" Blend mode: {}", xr::to_string(j));
}
}
}
void application::initialize()
{
// LogLayersAndExtensions
assert(!xr_instance);
std::vector<const char *> extensions{XR_KHR_CONVERT_TIMESPEC_TIME_EXTENSION_NAME /*, XR_KHR_COMPOSITION_LAYER_COLOR_SCALE_BIAS_EXTENSION_NAME*/};
for (XrExtensionProperties & i: xr::instance::extensions())
{
if (!strcmp(i.extensionName, XR_KHR_COMPOSITION_LAYER_COLOR_SCALE_BIAS_EXTENSION_NAME))
extensions.push_back(XR_KHR_COMPOSITION_LAYER_COLOR_SCALE_BIAS_EXTENSION_NAME);
if (!strcmp(i.extensionName, XR_FB_DISPLAY_REFRESH_RATE_EXTENSION_NAME))
extensions.push_back(XR_FB_DISPLAY_REFRESH_RATE_EXTENSION_NAME);
}
#ifdef XR_USE_PLATFORM_ANDROID
xr_instance =
xr::instance(app_info.name, app_info.native_app->activity->vm, app_info.native_app->activity->clazz, extensions);
#else
xr_instance = xr::instance(app_info.name, extensions);
#endif
spdlog::info("Created OpenXR instance, runtime {}, version {}", xr_instance.get_runtime_name(), xr_instance.get_runtime_version());
xr_system_id = xr::system(xr_instance, app_info.formfactor);
spdlog::info("Created OpenXR system for form factor {}", xr::to_string(app_info.formfactor));
// Log view configurations and blend modes
log_views();
initialize_vulkan();
xr_session = xr::session(xr_instance, xr_system_id, vk_instance, vk_physical_device, vk_device, vk_queue_family_index);
auto spaces = xr_session.get_reference_spaces();
spdlog::info("{} reference spaces", spaces.size());
for (XrReferenceSpaceType i: spaces)
{
spdlog::info(" {}", xr::to_string(i));
}
view_space = xr_session.create_reference_space(XR_REFERENCE_SPACE_TYPE_VIEW);
world_space = xr_session.create_reference_space(XR_REFERENCE_SPACE_TYPE_STAGE);
swapchain_format = VK_FORMAT_UNDEFINED;
for (auto i: xr_session.get_swapchain_formats())
{
if (std::find(supported_formats.begin(), supported_formats.end(), i) != supported_formats.end())
{
swapchain_format = i;
break;
}
}
if (swapchain_format == VK_FORMAT_UNDEFINED)
throw std::runtime_error("No supported swapchain format");
spdlog::info("Using format {}", string_VkFormat(swapchain_format));
// XrViewConfigurationProperties view_props = xr_system_id.view_configuration_properties(viewconfig);
auto views = xr_system_id.view_configuration_views(app_info.viewconfig);
xr_swapchains.reserve(views.size());
for (auto view: views)
{
view = override_view(view, guess_model());
xr_swapchains.emplace_back(xr_session, vk_device, swapchain_format, view.recommendedImageRectWidth, view.recommendedImageRectHeight);
spdlog::info("Created swapchain {}: {}x{}", xr_swapchains.size(), xr_swapchains.back().width(), xr_swapchains.back().height());
}
vk_cmdpool = vk::command_pool{vk_device, vk_queue_family_index};
// TODO get it from application info
xr_actionset = xr::actionset(xr_instance, "actions", "Actions");
switch (guess_model())
{
case model::oculus_quest:
case model::oculus_quest_2:
case model::meta_quest_3: {
spdlog::info("Suggesting oculus/touch_controller bindings");
std::vector<XrActionSuggestedBinding> touch_controller_bindings;
for (const auto & [name, type]: oculus_touch)
{
process_binding_action(touch_controller_bindings, name, type);
}
xr_instance.suggest_bindings("/interaction_profiles/oculus/touch_controller", touch_controller_bindings);
}
break;
case model::pico_neo_3: {
spdlog::info("Suggesting Pico Neo 3 bindings");
std::vector<XrActionSuggestedBinding> pico_neo_3_bindings;
for (const auto & [name, type]: pico_neo_3)
{
process_binding_action(pico_neo_3_bindings, name, type);
}
xr_instance.suggest_bindings("/interaction_profiles/bytedance/pico_neo3_controller", pico_neo_3_bindings);
}
break;
case model::pico_4: {
spdlog::info("Suggesting Pico 4 bindings");
std::vector<XrActionSuggestedBinding> pico_4_bindings;
for (const auto & [name, type]: pico_4)
{
process_binding_action(pico_4_bindings, name, type);
}
xr_instance.suggest_bindings("/interaction_profiles/bytedance/pico4_controller", pico_4_bindings);
}
case model::unknown: {
spdlog::info("Suggesting Khronos simple controller bindings");
std::vector<XrActionSuggestedBinding> simple_controller_bindings;
for (const auto & [name, type]: simple_controller)
{
process_binding_action(simple_controller_bindings, name, type);
}
xr_instance.suggest_bindings("/interaction_profiles/khr/simple_controller", simple_controller_bindings);
}
break;
}
xr_session.attach_actionsets({xr_actionset});
interaction_profile_changed();
}
void application::process_binding_action(std::vector<XrActionSuggestedBinding> & bindings,
const char * name,
const XrActionType & type)
{
std::string name_without_slashes = std::string(name).substr(1);
for (char & i: name_without_slashes)
{
if (i == '/')
i = '_';
}
auto a = xr_actionset.create_action(type, name_without_slashes);
actions.emplace_back(a, type, name);
if (type == XR_ACTION_TYPE_POSE_INPUT)
{
action_spaces.push_back(xr_session.create_action_space(a));
}
bindings.push_back({a, xr_instance.string_to_path(name)});
}
std::pair<XrAction, XrActionType> application::get_action(const std::string & requested_name)
{
for (const auto & [action, type, name]: instance_->actions)
{
if (name == requested_name)
return {action, type};
}
return {};
}
application::application(application_info info) :
app_info(std::move(info)), jni(*this)
{
#ifdef XR_USE_PLATFORM_ANDROID
// https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/types.html
JNIEnv * Env = jni.get_JNIEnv();
ANativeActivity * activity = app_info.native_app->activity;
jmethodID jtmID;
jclass jNativeClass = Env->GetObjectClass(activity->clazz);
jtmID = Env->GetMethodID(jNativeClass, "getApplication", "()Landroid/app/Application;");
jobject jNativeApplication = Env->CallObjectMethod(activity->clazz, jtmID);
jtmID = Env->GetMethodID(Env->GetObjectClass(jNativeApplication), "getApplicationContext", "()Landroid/content/Context;");
jobject jNativeContext = Env->CallObjectMethod(jNativeApplication, jtmID);
jfieldID jNativeWIFI_SERVICE_fid = Env->GetStaticFieldID(Env->GetObjectClass(jNativeContext), "WIFI_SERVICE", "Ljava/lang/String;");
jstring jNativeSFID_jstr = (jstring)Env->GetStaticObjectField(Env->FindClass("android/content/Context"), jNativeWIFI_SERVICE_fid);
jstring wifiLockjStr = Env->NewStringUTF("WIVRn");
jtmID = Env->GetMethodID(Env->FindClass("android/content/Context"), "getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;");
jobject jSystemService = Env->CallObjectMethod(jNativeContext, jtmID, jNativeSFID_jstr);
jclass jWMClass = Env->FindClass("android/net/wifi/WifiManager");
jclass jWMMLClass = Env->FindClass("android/net/wifi/WifiManager$MulticastLock");
jtmID = Env->GetMethodID(jWMClass, "createMulticastLock", "(Ljava/lang/String;)Landroid/net/wifi/WifiManager$MulticastLock;");
jobject jMCObj = Env->CallObjectMethod(jSystemService, jtmID, wifiLockjStr);
jtmID = Env->GetMethodID(jWMMLClass, "setReferenceCounted", "(Z)V");
Env->CallVoidMethod(jMCObj, jtmID, 0);
jtmID = Env->GetMethodID(jWMMLClass, "acquire", "()V");
Env->CallVoidMethod(jMCObj, jtmID);
jtmID = Env->GetMethodID(jWMMLClass, "isHeld", "()Z");
jboolean isheld = Env->CallBooleanMethod(jMCObj, jtmID);
if (isheld)
{
spdlog::info("MulticastLock acquired");
}
else
{
spdlog::info("MulticastLock is not acquired");
}
jclass jWMWLClass = Env->FindClass("android/net/wifi/WifiManager$WifiLock");
jtmID = Env->GetMethodID(jWMClass, "createWifiLock", "(ILjava/lang/String;)Landroid/net/wifi/WifiManager$WifiLock;");
// jobject jMCObj2 = Env->CallObjectMethod(jSystemService, jtmID, 4 /* WIFI_MODE_FULL_LOW_LATENCY */, wifiLockjStr);
jobject jMCObj2 = Env->CallObjectMethod(jSystemService, jtmID, 3 /* WIFI_MODE_FULL_HIGH_PERF */, wifiLockjStr);
jtmID = Env->GetMethodID(jWMWLClass, "setReferenceCounted", "(Z)V");
Env->CallVoidMethod(jMCObj2, jtmID, 0);
jtmID = Env->GetMethodID(jWMWLClass, "acquire", "()V");
Env->CallVoidMethod(jMCObj2, jtmID);
jtmID = Env->GetMethodID(jWMWLClass, "isHeld", "()Z");
isheld = Env->CallBooleanMethod(jMCObj2, jtmID);
if (isheld)
{
spdlog::info("WifiLock low latency acquired");
}
else
{
spdlog::info("WifiLock low latency is not acquired");
}
Env->DeleteLocalRef(wifiLockjStr);
// Get the intent, to handle wivrn://uri
jtmID = Env->GetMethodID(jNativeClass, "getIntent", "()Landroid/content/Intent;");
jobject intent = Env->CallObjectMethod(activity->clazz, jtmID);
jtmID = Env->GetMethodID(Env->GetObjectClass(intent), "getDataString", "()Ljava/lang/String;");
jstring dataString_jni = (jstring)Env->CallObjectMethod(intent, jtmID);
std::string dataString;
if (dataString_jni)
{
const char * dataString_c = Env->GetStringUTFChars(dataString_jni, NULL);
dataString = dataString_c;
Env->ReleaseStringUTFChars(dataString_jni, dataString_c);
}
spdlog::info("dataString = {}", dataString);
if (dataString.starts_with("wivrn://"))
{
server_address = dataString.substr(strlen("wivrn://"));
}
app_info.native_app->userData = this;
app_info.native_app->onAppCmd = [](android_app * app, int32_t cmd) {
switch (cmd)
{
// There is no APP_CMD_CREATE. The ANativeActivity creates the
// application thread from onCreate(). The application thread
// then calls android_main().
case APP_CMD_START:
break;
case APP_CMD_RESUME:
static_cast<application *>(app->userData)->resumed = true;
break;
case APP_CMD_PAUSE:
static_cast<application *>(app->userData)->resumed = false;
break;
case APP_CMD_STOP:
break;
case APP_CMD_DESTROY:
static_cast<application *>(app->userData)->native_window = nullptr;
break;
case APP_CMD_INIT_WINDOW:
static_cast<application *>(app->userData)->native_window = app->window;
break;
case APP_CMD_TERM_WINDOW:
static_cast<application *>(app->userData)->native_window = nullptr;
break;
}
};
// Initialize the loader for this platform
PFN_xrInitializeLoaderKHR initializeLoader = nullptr;
if (XR_SUCCEEDED(xrGetInstanceProcAddr(XR_NULL_HANDLE, "xrInitializeLoaderKHR", (PFN_xrVoidFunction *)(&initializeLoader))))
{
XrLoaderInitInfoAndroidKHR loaderInitInfoAndroid{};
loaderInitInfoAndroid.type = XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR;
loaderInitInfoAndroid.next = nullptr;
loaderInitInfoAndroid.applicationVM = app_info.native_app->activity->vm;
loaderInitInfoAndroid.applicationContext = app_info.native_app->activity->clazz;
initializeLoader((const XrLoaderInitInfoBaseHeaderKHR *)&loaderInitInfoAndroid);
}
#endif
assert(instance_ == nullptr);
instance_ = this;
try
{
initialize();
}
catch (...)
{
cleanup();
throw;
}
}
void application::cleanup()
{
// The Vulkan device and instance are destroyed by the OpenXR runtime
#ifdef XR_USE_PLATFORM_ANDROID
app_info.native_app->activity->vm->DetachCurrentThread();
#endif
assert(instance_ == this);
instance_ = nullptr;
}
application::~application()
{
cleanup();
}
void application::loop()
{
poll_events();
if (!is_session_running())
{
// Throttle loop since xrWaitFrame won't be called.
std::this_thread::sleep_for(250ms);
}
else
{
poll_actions();
auto scene = current_scene();
if (scene)
{
if (scene != last_scene)
{
if (last_scene)
last_scene->on_unfocused();
scene->on_focused();
last_scene = scene;
}
scene->render();
}
else
{
exit_requested = true;
}
}
}
#ifdef XR_USE_PLATFORM_ANDROID
void application::run()
{
std::thread application_thread{[&]() {
jni_thread jni;
while (!is_exit_requested())
{
try
{
loop();
}
catch (std::exception & e)
{
spdlog::error("Caught exception in application_thread: \"{}\"", e.what());
exit_requested = true;
}
catch (...)
{
spdlog::error("Caught unknown exception in application_thread");
exit_requested = true;
}
}
}};
pthread_setname_np(application_thread.native_handle(), "application_thread");
// Read all pending events.
while (!exit_requested)
{
int events;
struct android_poll_source * source;
while (ALooper_pollAll(-1, nullptr, &events, (void **)&source) >= 0)
{
// Process this event.
if (source != nullptr)
source->process(app_info.native_app, source);
}
if (app_info.native_app->destroyRequested)
{
exit_requested = true;
}
}
application_thread.join();
}
#else
void application::run()
{
while (!is_exit_requested())
{
loop();
}
}
#endif
std::shared_ptr<scene> application::current_scene()
{
std::unique_lock _{instance_->scene_stack_lock};
if (!instance_->scene_stack.empty())
return instance_->scene_stack.back();
else
return {};
}
void application::pop_scene()
{
std::unique_lock _{instance_->scene_stack_lock};
if (!instance_->scene_stack.empty())
instance_->scene_stack.pop_back();
}
void application::push_scene(std::shared_ptr<scene> s)
{
std::unique_lock _{instance_->scene_stack_lock};
instance_->scene_stack.push_back(std::move(s));
}
void application::poll_actions()
{
instance_->xr_session.sync_actions(instance_->xr_actionset);
}
bool application::read_action(XrAction action, bool & value, XrTime & last_change_time)
{
if (!is_focused())
return false;
XrActionStateGetInfo get_info{
.type = XR_TYPE_ACTION_STATE_GET_INFO,
.action = action,
};
XrActionStateBoolean state{XR_TYPE_ACTION_STATE_BOOLEAN};
CHECK_XR(xrGetActionStateBoolean(instance_->xr_session, &get_info, &state));
if (!state.isActive)
return false;
value = state.currentState;
last_change_time = state.lastChangeTime;
return true;
}
bool application::read_action(XrAction action, float & value, XrTime & last_change_time)
{
if (!is_focused())
return false;
XrActionStateGetInfo get_info{
.type = XR_TYPE_ACTION_STATE_GET_INFO,
.action = action,
};
XrActionStateFloat state{XR_TYPE_ACTION_STATE_FLOAT};
CHECK_XR(xrGetActionStateFloat(instance_->xr_session, &get_info, &state));
if (!state.isActive)
return false;
value = state.currentState;
last_change_time = state.lastChangeTime;
return true;
}
bool application::read_action(XrAction action, XrVector2f & value, XrTime & last_change_time)
{
if (!is_focused())
return false;
XrActionStateGetInfo get_info{
.type = XR_TYPE_ACTION_STATE_GET_INFO,
.action = action,
};
XrActionStateVector2f state{XR_TYPE_ACTION_STATE_VECTOR2F};
CHECK_XR(xrGetActionStateVector2f(instance_->xr_session, &get_info, &state));
if (!state.isActive)
return false;
value = state.currentState;
last_change_time = state.lastChangeTime;
return true;
}
void application::haptic_start(XrAction action, XrPath subpath, int64_t duration, float frequency, float amplitude)
{
if (!is_focused())
return;
XrHapticActionInfo action_info{
.type = XR_TYPE_HAPTIC_ACTION_INFO,
.action = action,
.subactionPath = subpath,
};
XrHapticVibration vibration{
.type = XR_TYPE_HAPTIC_VIBRATION,
.duration = duration,
.frequency = frequency,
.amplitude = amplitude};
xrApplyHapticFeedback(application::instance_->xr_session, &action_info, (XrHapticBaseHeader *)&vibration);
}
void application::haptic_stop(XrAction action, XrPath subpath)
{
if (!is_focused())
return;
XrHapticActionInfo action_info{
.type = XR_TYPE_HAPTIC_ACTION_INFO,
.action = action,
.subactionPath = subpath,
};
xrStopHapticFeedback(application::instance_->xr_session, &action_info);
}
void application::session_state_changed(XrSessionState new_state, XrTime timestamp)
{
// See HandleSessionStateChangedEvent
spdlog::info("Session state changed at timestamp {}: {} => {}", timestamp, xr::to_string(session_state), xr::to_string(new_state));
session_state = new_state;
switch (new_state)
{
case XR_SESSION_STATE_READY:
xr_session.begin_session(app_info.viewconfig);
session_running = true;
break;
case XR_SESSION_STATE_SYNCHRONIZED:
session_visible = false;
session_focused = false;
break;
case XR_SESSION_STATE_VISIBLE:
session_visible = true;
session_focused = false;
break;
case XR_SESSION_STATE_FOCUSED:
session_visible = true;
session_focused = true;
break;
case XR_SESSION_STATE_STOPPING:
session_visible = false;
session_focused = false;
xr_session.end_session();
session_running = false;
break;
case XR_SESSION_STATE_EXITING:
exit_requested = true;
break;
case XR_SESSION_STATE_LOSS_PENDING:
exit_requested = true;
break;
default:
break;
}
}
void application::interaction_profile_changed()
{
spdlog::info("Interaction profile changed");
for (auto i: {"/user/hand/left", "/user/hand/right", "/user/head", "/user/gamepad"})
{
try
{
spdlog::info("Current interaction profile for {}: {}", i, xr_session.get_current_interaction_profile(i));
}
catch (std::exception & e)
{
spdlog::warn("Cannot get current interaction profile for {}: {}", i, e.what());
continue;
}
}
for (auto [i, j]: utils::zip(actions, oculus_touch))
{
auto sources = xr_session.localized_sources_for_action(std::get<XrAction>(i));
if (!sources.empty())
{
spdlog::info(" Sources for {}", j.first);
for (auto & k: sources)
{
spdlog::info(" {}", k);
}
}
else
{
spdlog::warn(" No source for {}", j.first);
}
}
}
void application::poll_events()
{
xr::event e;
while (xr_instance.poll_event(e))
{
switch (e.header.type)
{
case XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING: {
exit_requested = true;
}
break;
case XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED: {
if (e.interaction_profile_changed.session == xr_session)
interaction_profile_changed();
else
spdlog::error("Received XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED for "
"unknown session");
}
break;
case XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING: {
spdlog::warn("XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING in space {} in {:.6}s", magic_enum::enum_name(e.space_changed_pending.referenceSpaceType), (e.space_changed_pending.changeTime - now()) / 1.e9);
}
break;
case XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED: {
if (e.state_changed.session == xr_session)
session_state_changed(e.state_changed.state, e.state_changed.time);
else
spdlog::error("Received XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED for unknown "
"session");
}
break;
default:
spdlog::info("Received event type {}", xr::to_string(e.header.type));
break;
}
}
}