sOpenXR.cpp

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2022 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 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 Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#include "sOpenXR.h"
#include <set>
#include <iostream>
 
#if !defined(XR_USE_PLATFORM_WIN32)
# define strcpy_s(dest, source) strncpy((dest), (source), sizeof(dest))
#endif
 
//Common functions
bool xr_result(XrInstance instance, XrResult result, const char* format, ...)
{
  if (XR_SUCCEEDED(result))
    return true;
 
  char resultString[XR_MAX_RESULT_STRING_SIZE];
 
  if (instance != XR_NULL_HANDLE)
  {
    xrResultToString(instance, result, resultString);
 
    size_t len1 = strlen(format);
    size_t len2 = strlen(resultString) + 1;
    char *formatRes = new  char[len1 + len2 + 15]; // + "[OPENXR]: []\n"
    sprintf(formatRes, "[OPENXR]: %s [%s]\n", format, resultString);
 
    va_list args;
    va_start(args, format);
    MMechostr(MSKRUNTIME, formatRes, args);
    va_end(args);
 
    delete[] formatRes;
  }
  else
  {
    size_t len1 = strlen(format);
    char *formatRes = new char[len1 + 12]; // + "[OPENXR]: \n"
    sprintf(formatRes, "[OPENXR]: %s\n", format);
    MMechostr(MSKRUNTIME, formatRes);
    delete[] formatRes;
  }
  return false;
}
 
void get_instance_properties(XrInstance instance)
{
  XrResult result;
  XrInstanceProperties instance_props = { XR_TYPE_INSTANCE_PROPERTIES, XR_NULL_HANDLE };
  std::stringstream buf;
 
  result = xrGetInstanceProperties(instance, &instance_props);
  if (!xr_result(XR_NULL_HANDLE, result, "Failed to get instance info"))
    return;
 
  buf << "[OPENXR]: Runtime Name: " << instance_props.runtimeName << "\n"
    << "Runtime Version: " << XR_VERSION_MAJOR(instance_props.runtimeVersion) << "." << XR_VERSION_MINOR(instance_props.runtimeVersion) << "." << XR_VERSION_PATCH(instance_props.runtimeVersion) << std::endl;
  MMechostr(MSKRUNTIME, buf.str().c_str());
}
 
void print_system_properties(XrSystemProperties* system_properties, bool hand_tracking_ext)
{
  std::stringstream buf;
  buf << "[OPENXR]: System properties for system " << system_properties->systemId << " \""
    << system_properties->systemName << "\", vendor ID " << system_properties->vendorId << "\n"
    << "\tMax layers          : " << system_properties->graphicsProperties.maxLayerCount << "\n"
    << "\tMax swapchain height: " << system_properties->graphicsProperties.maxSwapchainImageHeight << "\n"
    << "\tMax swapchain width : " << system_properties->graphicsProperties.maxSwapchainImageWidth << "\n"
    << "\tOrientation Tracking: " << system_properties->trackingProperties.orientationTracking << "\n"
    << "\tPosition Tracking   : " << system_properties->trackingProperties.positionTracking;
 
  if (hand_tracking_ext)
  {
    //XrSystemHandTrackingPropertiesEXT* ht = (XrSystemHandTrackingPropertiesEXT*)system_properties->next;
    buf << "\tHand Tracking       : true"; // << ht->supportsHandTracking;
  }
  buf << std::endl;
  MMechostr(MSKRUNTIME, buf.str().c_str());
}
 
// Initialize singleton
sOpenXr* sOpenXr::_singleton = nullptr;
 
sOpenXr::sOpenXr(RenderSystem rsys, float scaleRatio)
{
  mRendererType = rsys;
  mAppName = "Scol OpenXR plugin";
  mInstance = XR_NULL_HANDLE;
  mSession = XR_NULL_HANDLE;
  mConnected = false;
  mPaused = false;
  mFrameIndex = 1;
  mLastIPD = 0.064f;
  mPredictedDisplayTime = 0;
  mScaleRatio = scaleRatio;
  mSessionRunning = false;
  mRequestRestart = false;
  mPoseValid = false;
  mViewType = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO;
  mPassthroughEnable = false;
  mSkipNextFrame = false;
  mSystemId = XR_NULL_SYSTEM_ID;
  mSession = XR_NULL_HANDLE;
  mInstance = XR_NULL_HANDLE;
  mLastControllerType = ControllerType::CLASSIC_CONTROLLER;
  mExtensionsEnable = ExtensionType::EXTENSION_NONE;
 
  for (unsigned int i = 0; i < MAX_VR_CONTROLLERS; i++)
    mControllerType[i] = ControllerType::CLASSIC_CONTROLLER;
 
  for (unsigned int i = 0; i < 2; i++)
    mFov[i] = 0;
 
  mBlendMode = XR_ENVIRONMENT_BLEND_MODE_OPAQUE;
  mHandTracking.gestures = false;
  mHandTracking.supported = false;
  mHandTracking.system_supported = false;
 
  mPassthroughFB.supported = false;
  mPassthroughFB.available = false;
  mPassthroughFB.passthroughLayer = XR_NULL_HANDLE;
  mPassthroughFB.pfnXrCreatePassthroughFBX = XR_NULL_HANDLE;
  mPassthroughFB.pfnXrDestroyPassthroughFBX = XR_NULL_HANDLE;
  mPassthroughFB.pfnXrPassthroughPauseFBX = XR_NULL_HANDLE;
  mPassthroughFB.pfnXrPassthroughStartFBX = XR_NULL_HANDLE;
  mPassthroughFB.pfnXrCreatePassthroughLayerFBX = XR_NULL_HANDLE;
  mPassthroughFB.pfnXrDestroyPassthroughLayerFBX = XR_NULL_HANDLE;
  mPassthroughFB.pfnXrPassthroughLayerPauseFBX = XR_NULL_HANDLE;
  mPassthroughFB.pfnXrPassthroughLayerResumeFBX = XR_NULL_HANDLE;
  mPassthroughFB.passthroughFeature = XR_NULL_HANDLE;
 
  mPassthroughHTC.supported = false;
  mPassthroughHTC.passthroughFeature = XR_NULL_HANDLE;
  mPassthroughHTC.pfnXrCreatePassthroughHTC = XR_NULL_HANDLE;
  mPassthroughHTC.pfnXrDestroyPassthroughHTC = XR_NULL_HANDLE;
 
  //initialize platform
  std::shared_ptr<PlatformData> data = std::make_shared<PlatformData>();
 
#if defined(XR_USE_PLATFORM_WIN32)
  mPlatform = CreatePlatform(data);
#elif defined(XR_USE_PLATFORM_ANDROID)
  struct android_app* androidApp = (struct android_app*)SCgetExtra("this_inst");
 
  JNIEnv* Env;
  androidApp->activity->vm->AttachCurrentThread(&Env, nullptr);
 
  data->applicationVM = androidApp->activity->vm;
  data->applicationActivity = androidApp->activity->clazz;
 
  mPlatform = CreatePlatform(data);
 
  // Initialize the loader for this platform
  PFN_xrInitializeLoaderKHR initializeLoader = XR_NULL_HANDLE;
  if (XR_SUCCEEDED(xrGetInstanceProcAddr(XR_NULL_HANDLE, "xrInitializeLoaderKHR", (PFN_xrVoidFunction*)(&initializeLoader))))
  {
    XrLoaderInitInfoAndroidKHR loaderInitInfoAndroid;
    memset(&loaderInitInfoAndroid, 0, sizeof(loaderInitInfoAndroid));
    loaderInitInfoAndroid.type = XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR;
    loaderInitInfoAndroid.next = XR_NULL_HANDLE;
    loaderInitInfoAndroid.applicationVM = androidApp->activity->vm;
    loaderInitInfoAndroid.applicationContext = androidApp->activity->clazz;
    initializeLoader((const XrLoaderInitInfoBaseHeaderKHR*)&loaderInitInfoAndroid);
  }
#endif
 
  //initialize renderer
  mRenderer = CreateRenderer(mRendererType);
}
 
sOpenXr::~sOpenXr()
{
  Disconnect();
 
#if defined(XR_USE_PLATFORM_ANDROID)
  struct android_app* androidApp = (struct android_app*)SCgetExtra("this_inst");
  androidApp->activity->vm->DetachCurrentThread();
#endif
}
 
void sOpenXr::SetRenderer(RenderSystem renderer)
{
  if (mRendererType != renderer)
  {
    mRendererType = renderer;
    if (mConnected)
    {
      Disconnect();
      mRenderer = CreateRenderer(renderer);
      Connect();
    }
    else
    {
      mRenderer = CreateRenderer(renderer);
    }
  }
}
 
void sOpenXr::SetExtensions(int extensions)
{
  if (extensions != mExtensionsEnable)
  {
    mExtensionsEnable = extensions;
 
    if (mConnected)
    {
      Disconnect();
      Connect();
    }
  }
}
 
 
void sOpenXr::SetAppName(std::string name)
{
  mAppName = name;
  if (mConnected)
  {
    Disconnect();
    Connect();
  }
}
 
bool sOpenXr::SetSceneBlendMode(XrEnvironmentBlendMode mode)
{
  uint32_t blendCount;
  xrEnumerateEnvironmentBlendModes(mInstance, mSystemId, mViewType, 0, &blendCount, nullptr);
 
  if (blendCount > 0)
  {
    std::vector<XrEnvironmentBlendMode> blendModes(blendCount);
    xrEnumerateEnvironmentBlendModes(mInstance, mSystemId, mViewType, blendCount, &blendCount, blendModes.data());
 
    for (const auto& blendMode : blendModes)
    {
      if (blendMode == mode)
      {
        mBlendMode = blendMode;
        return true;
      }
    }
  }
  return false;
}
 
int sOpenXr::GetExtensions()
{
  return mExtensionsEnable;
}
 
bool sOpenXr::initialize()
{
  XrResult result;
  mRequestRestart = false;
 
  if (!mRenderer->Setup())
    return false;
 
  // xrEnumerate*() functions are usually called once with CapacityInput = 0.
  // The function will write the required amount into CountOutput. We then have
  // to allocate an array to hold CountOutput elements and call the function
  // with CountOutput as CapacityInput.
  uint32_t ext_count = 0;
  result = xrEnumerateInstanceExtensionProperties(XR_NULL_HANDLE, 0, &ext_count, XR_NULL_HANDLE);
 
  if (!xr_result(XR_NULL_HANDLE, result, "Failed to enumerate number of extension properties"))
    return false;
 
  MMechostr(MSKRUNTIME, "[OPENXR]: Runtime supports %d extensions\n", ext_count);
 
  std::vector<XrExtensionProperties> extensionProperties(ext_count, { XR_TYPE_EXTENSION_PROPERTIES, XR_NULL_HANDLE });
  result = xrEnumerateInstanceExtensionProperties(XR_NULL_HANDLE, ext_count, &ext_count, extensionProperties.data());
  if (!xr_result(XR_NULL_HANDLE, result, "Failed to enumerate extension properties"))
    return false;
 
  //Hack Pico to disable not totally functional hand tracking
  bool rendererSupport = false;
  mHandTracking.supported = false;
  mHandTracking.gestures = false;
  mPassthroughFB.supported = false;
  mPassthroughHTC.supported = false;
  mPicoController.supported = false;
 
  for (uint32_t i = 0; i < ext_count; i++)
  {
    MMechostr(MSKRUNTIME, "\t%s v%d\n", extensionProperties[i].extensionName, extensionProperties[i].extensionVersion);
 
    if (strcmp(mRenderer->GetExtension(), extensionProperties[i].extensionName) == 0)
      rendererSupport = true;
 
    if ((strcmp(XR_EXT_HAND_TRACKING_EXTENSION_NAME, extensionProperties[i].extensionName) == 0) && (mExtensionsEnable & EXTENSION_HAND_TRACKING))
    {
      mHandTracking.supported = true;
      mHandTracking.trackers[VrController::Left] = 0;
      mHandTracking.trackers[VrController::Right] = 0;
    }
 
    if ((strcmp(XR_FB_HAND_TRACKING_AIM_EXTENSION_NAME, extensionProperties[i].extensionName) == 0) && (mExtensionsEnable & EXTENSION_HAND_TRACKING))
      mHandTracking.gestures = true;
 
    if ((strcmp(XR_FB_PASSTHROUGH_EXTENSION_NAME, extensionProperties[i].extensionName) == 0) && (mExtensionsEnable & EXTENSION_PASSTHROUGH))
      mPassthroughFB.supported = true;
 
    if ((strcmp(XR_HTC_PASSTHROUGH_EXTENSION_NAME, extensionProperties[i].extensionName) == 0) && (mExtensionsEnable & EXTENSION_PASSTHROUGH))
      mPassthroughHTC.supported = true;
 
    if (strcmp(XR_BD_CONTROLLER_INTERACTION_EXTENSION_NAME, extensionProperties[i].extensionName) == 0)
      mPicoController.supported = true;
  }
 
  // A graphics extension like OpenGL is required to draw anything in VR
  if (!rendererSupport)
  {
    MMechostr(MSKRUNTIME, "[OPENXR]: Runtime does not support Renderer API extension!\n");
    return false;
  }
 
  // --- Create XrInstance
  std::vector<const char*> extensions;
 
  MMechostr(MSKRUNTIME, "[OPENXR]: Runtime supports extensions:\n");
  MMechostr(MSKRUNTIME, "\t%s\n", mRenderer->GetExtension());
  extensions.push_back(mRenderer->GetExtension());
 
  MMechostr(MSKRUNTIME, "\t%s: %d\n", XR_EXT_HAND_TRACKING_EXTENSION_NAME, mHandTracking.supported);
  MMechostr(MSKRUNTIME, "\t%s: %d\n", XR_FB_HAND_TRACKING_AIM_EXTENSION_NAME, mHandTracking.gestures);
  MMechostr(MSKRUNTIME, "\t%s: %d\n", XR_FB_PASSTHROUGH_EXTENSION_NAME, mPassthroughFB.supported);
  MMechostr(MSKRUNTIME, "\t%s: %d\n", XR_HTC_PASSTHROUGH_EXTENSION_NAME, mPassthroughHTC.supported);
  MMechostr(MSKRUNTIME, "\t%s: %d\n", XR_BD_CONTROLLER_INTERACTION_EXTENSION_NAME, mPicoController.supported);
 
  if (mHandTracking.supported)
    extensions.push_back(XR_EXT_HAND_TRACKING_EXTENSION_NAME);
 
  if (mHandTracking.gestures)
    extensions.push_back(XR_FB_HAND_TRACKING_AIM_EXTENSION_NAME);
 
  if (mPassthroughFB.supported)
    extensions.push_back(XR_FB_PASSTHROUGH_EXTENSION_NAME);
 
  if (mPassthroughHTC.supported)
    extensions.push_back(XR_HTC_PASSTHROUGH_EXTENSION_NAME);
 
  if (mPicoController.supported)
    extensions.push_back(XR_BD_CONTROLLER_INTERACTION_EXTENSION_NAME);
 
  // Transform platform and graphics extension std::strings to C strings.
  const std::vector<std::string> platformExtensions = mPlatform->GetInstanceExtensions();
  std::transform(platformExtensions.begin(), platformExtensions.end(), std::back_inserter(extensions),
                 [](const std::string& ext) { return ext.c_str(); });
 
  XrInstanceCreateInfo createInfo{ XR_TYPE_INSTANCE_CREATE_INFO };
  createInfo.next = mPlatform->GetInstanceCreateExtension();
  createInfo.enabledExtensionCount = (uint32_t)extensions.size();
  createInfo.enabledExtensionNames = extensions.data();
 
  strcpy_s(createInfo.applicationInfo.applicationName, mAppName.c_str());
  createInfo.applicationInfo.apiVersion = XR_CURRENT_API_VERSION;
  strcpy_s(createInfo.applicationInfo.engineName, "OpenSpace3D - Scol Engine");
  createInfo.applicationInfo.applicationVersion = 1;
 
  result = xrCreateInstance(&createInfo, &mInstance);
  if (!xr_result(XR_NULL_HANDLE, result, "Failed to create XR instance."))
    return false;
 
  // Optionally get runtime name and version
  get_instance_properties(mInstance);
 
  // --- Create XrSystem
  XrSystemGetInfo system_get_info = { XR_TYPE_SYSTEM_GET_INFO, XR_NULL_HANDLE, XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY };
 
  result = xrGetSystem(mInstance, &system_get_info, &mSystemId);
  if (!xr_result(mInstance, result, "Failed to get system for HMD form factor.") || (mSystemId == XR_NULL_SYSTEM_ID))
  {
    xrDestroyInstance(mInstance);
    return false;
  }
 
  MMechostr(MSKRUNTIME, "[OPENXR]: Successfully got XrSystem with id %lu for HMD form factor\n", mSystemId);
 
  // checking system properties is generally optional, but we are interested in hand tracking
  // support
  XrSystemHandTrackingPropertiesEXT hand_tracking_props = { XR_TYPE_SYSTEM_HAND_TRACKING_PROPERTIES_EXT };
  XrSystemPassthroughProperties2FB passthrough_props{XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES_FB};
  XrSystemProperties system_props = { XR_TYPE_SYSTEM_PROPERTIES };
 
  if (mHandTracking.supported)
  {
    if (mPassthroughFB.supported)
      hand_tracking_props.next = &passthrough_props;
 
    system_props.next = &hand_tracking_props;
  }
  else if (mPassthroughFB.supported)
  {
    system_props.next = &passthrough_props;
  }
 
  result = xrGetSystemProperties(mInstance, mSystemId, &system_props);
  if (!xr_result(mInstance, result, "Failed to get System properties"))
  {
    xrDestroyInstance(mInstance);
    return false;
  }
 
  mHandTracking.system_supported = mHandTracking.supported && hand_tracking_props.supportsHandTracking;
  mHandTracking.gestures = mHandTracking.gestures && mHandTracking.system_supported;
  //mPassthroughFB.supported = mPassthroughFB.supported && (passthrough_props.capabilities & XR_PASSTHROUGH_CAPABILITY_BIT_FB);
 
  mDeviceName = system_props.systemName;
  print_system_properties(&system_props, mHandTracking.supported);
  mIsPico = (mDeviceName == "SteamVR/OpenXR : pico") || (mDeviceName == "PICO 4") || (mDeviceName == "PICO 4 Pro") || (mDeviceName == "Pico Neo 3 Pro Eye");
 
  printSupportedViewConfigs();
 
  uint32_t view_count = 0;
  result = xrEnumerateViewConfigurationViews(mInstance, mSystemId, mViewType, 0, &view_count, XR_NULL_HANDLE);
  if (!xr_result(mInstance, result, "Failed to get view configuration view count!"))
  {
    xrDestroyInstance(mInstance);
    return false;
  }
 
  mViewconfigViews.resize(view_count, { XR_TYPE_VIEW_CONFIGURATION_VIEW, XR_NULL_HANDLE });
  mViews.resize(view_count, { XR_TYPE_VIEW });
 
  result = xrEnumerateViewConfigurationViews(mInstance, mSystemId, mViewType, view_count, &view_count, mViewconfigViews.data());
  if (!xr_result(mInstance, result, "Failed to enumerate view configuration views!"))
  {
    xrDestroyInstance(mInstance);
    return false;
  }
 
  printViewconfigViewInfo();
 
  if (!mRenderer->Check(mSystemId, mInstance))
  {
    xrDestroyInstance(mInstance);
    return false;
  }
 
  // --- Create session
  mState = XR_SESSION_STATE_UNKNOWN;
  XrSessionCreateInfo session_create_info = { XR_TYPE_SESSION_CREATE_INFO, mRenderer->GetBindings(), 0, mSystemId };
 
  result = xrCreateSession(mInstance, &session_create_info, &mSession);
  if (!xr_result(mInstance, result, "Failed to create session"))
  {
    xrDestroyInstance(mInstance);
    return false;
  }
 
  MMechostr(MSKRUNTIME, "[OPENXR]: Successfully created a session!\n");
 
  if (mHandTracking.system_supported)
  {
    result = xrGetInstanceProcAddr(mInstance, "xrLocateHandJointsEXT", reinterpret_cast<PFN_xrVoidFunction *>(&mHandTracking.pfnLocateHandJointsEXT));
    xr_result(mInstance, result, "Failed to get xrLocateHandJointsEXT function!");
 
    PFN_xrCreateHandTrackerEXT pfnCreateHandTrackerEXT = XR_NULL_HANDLE;
    result = xrGetInstanceProcAddr(mInstance, "xrCreateHandTrackerEXT", reinterpret_cast<PFN_xrVoidFunction *>(&pfnCreateHandTrackerEXT));
 
    if (!xr_result(mInstance, result, "Failed to get xrCreateHandTrackerEXT function!"))
      mHandTracking.system_supported = false;
 
    XrHandTrackerCreateInfoEXT hand_tracker_create_info_l = { XR_TYPE_HAND_TRACKER_CREATE_INFO_EXT, XR_NULL_HANDLE, XR_HAND_LEFT_EXT, XR_HAND_JOINT_SET_DEFAULT_EXT };
    result = pfnCreateHandTrackerEXT(mSession, &hand_tracker_create_info_l, &mHandTracking.trackers[VrController::Left]);
    if (!xr_result(mInstance, result, "Failed to create left hand tracker"))
      mHandTracking.system_supported = false;
 
    MMechostr(MSKRUNTIME, "[OPENXR]: Created hand tracker for left hand\n");
 
    XrHandTrackerCreateInfoEXT hand_tracker_create_info_r = { XR_TYPE_HAND_TRACKER_CREATE_INFO_EXT, XR_NULL_HANDLE, XR_HAND_RIGHT_EXT, XR_HAND_JOINT_SET_DEFAULT_EXT };
    result = pfnCreateHandTrackerEXT(mSession, &hand_tracker_create_info_r, &mHandTracking.trackers[VrController::Right]);
    if (!xr_result(mInstance, result, "Failed to create right hand tracker"))
      mHandTracking.system_supported = false;
 
    MMechostr(MSKRUNTIME, "[OPENXR]: Created hand tracker for right hand\n");
  }
 
  if (mPassthroughFB.supported)
  {
    if (!xr_result(mInstance, xrGetInstanceProcAddr(mInstance, "xrCreatePassthroughFB",
      reinterpret_cast<PFN_xrVoidFunction *>(&mPassthroughFB.pfnXrCreatePassthroughFBX)),
        "Failed to obtain the function pointer for xrCreatePassthroughFB") ||
 
        !xr_result(mInstance, xrGetInstanceProcAddr(mInstance, "xrDestroyPassthroughFB",
          reinterpret_cast<PFN_xrVoidFunction *>(&mPassthroughFB.pfnXrDestroyPassthroughFBX)),
        "Failed to obtain the function pointer for xrDestroyPassthroughFB") ||
 
        !xr_result(mInstance, xrGetInstanceProcAddr(mInstance, "xrCreatePassthroughLayerFB",
          reinterpret_cast<PFN_xrVoidFunction *>(&mPassthroughFB.pfnXrCreatePassthroughLayerFBX)),
        "Failed to obtain the function pointer for xrCreatePassthroughLayerFBX") ||
 
        !xr_result(mInstance, xrGetInstanceProcAddr(mInstance, "xrPassthroughStartFB",
          reinterpret_cast<PFN_xrVoidFunction *>(&mPassthroughFB.pfnXrPassthroughStartFBX)),
        "Failed to obtain the function pointer for xrPassthroughStartFB") ||
 
        !xr_result(mInstance, xrGetInstanceProcAddr(mInstance, "xrPassthroughPauseFB",
          reinterpret_cast<PFN_xrVoidFunction *>(&mPassthroughFB.pfnXrPassthroughPauseFBX)),
        "Failed to obtain the function pointer for xrPassthroughPauseFB") ||
 
        !xr_result(mInstance, xrGetInstanceProcAddr(mInstance, "xrPassthroughLayerResumeFB",
          reinterpret_cast<PFN_xrVoidFunction *>(&mPassthroughFB.pfnXrPassthroughLayerResumeFBX)),
        "Failed to obtain the function pointer for xrPassthroughLayerResumeFB") ||
 
        !xr_result(mInstance, xrGetInstanceProcAddr(mInstance, "xrPassthroughLayerPauseFB",
          reinterpret_cast<PFN_xrVoidFunction *>(&mPassthroughFB.pfnXrPassthroughLayerPauseFBX)),
        "Failed to obtain the function pointer for xrPassthroughLayerPauseFB") ||
 
        !xr_result(mInstance, xrGetInstanceProcAddr(mInstance, "xrDestroyPassthroughLayerFB",
          reinterpret_cast<PFN_xrVoidFunction *>(&mPassthroughFB.pfnXrDestroyPassthroughLayerFBX)),
        "Failed to obtain the function pointer for xrDestroyPassthroughLayerFB") ||
 
        !xr_result(mInstance, xrGetInstanceProcAddr(mInstance, "xrPassthroughLayerSetStyleFB",
          reinterpret_cast<PFN_xrVoidFunction *>(&mPassthroughFB.pfnXrPassthroughLayerSetStyleFB)),
        "Failed to obtain the function pointer for xrPassthroughLayerSetStyleFB"))
      mPassthroughFB.supported = false;
  }
 
  if (mPassthroughHTC.supported)
  {
    if (!xr_result(mInstance, xrGetInstanceProcAddr(mInstance, "xrCreatePassthroughHTC",
      reinterpret_cast<PFN_xrVoidFunction *>(&mPassthroughHTC.pfnXrCreatePassthroughHTC)),
        "Failed to obtain the function pointer for xrCreatePassthroughHTC") ||
       
      !xr_result(mInstance, xrGetInstanceProcAddr(mInstance, "xrDestroyPassthroughHTC",
        reinterpret_cast<PFN_xrVoidFunction *>(&mPassthroughHTC.pfnXrDestroyPassthroughHTC)),
        "Failed to obtain the function pointer for xrDestroyPassthroughHTC"))
      mPassthroughHTC.supported = false;
  }
 
  printReferenceSpaces();
 
  XrReferenceSpaceCreateInfo play_space_create_info = { XR_TYPE_REFERENCE_SPACE_CREATE_INFO, XR_NULL_HANDLE, XR_REFERENCE_SPACE_TYPE_STAGE, identity_pose };
 
  result = xrCreateReferenceSpace(mSession, &play_space_create_info, &mPlaySpace);
  if (!xr_result(mInstance, result, "Failed to create play space!"))
  {
    xrDestroySession(mSession);
    xrDestroyInstance(mInstance);
    return false;
  }
 
  XrReferenceSpaceCreateInfo view_space_info = { XR_TYPE_REFERENCE_SPACE_CREATE_INFO, XR_NULL_HANDLE, XR_REFERENCE_SPACE_TYPE_VIEW, identity_pose };
  result = xrCreateReferenceSpace(mSession, &view_space_info, &mViewSpace);
  if (!xr_result(mInstance, result, "Failed to create view space!"))
  {
    xrDestroySession(mSession);
    xrDestroyInstance(mInstance);
    return false;
  }
 
  // --- Create Swapchains
  int64_t swapchainFormat = 0;
  if (!mRenderer->GetSwapchainFormat(mInstance, mSession, swapchainFormat))
  {
    xrDestroySession(mSession);
    xrDestroyInstance(mInstance);
    return false;
  }
 
  /* All OpenGL textures that will be submitted in xrEndFrame are created by the runtime here.
   * The runtime will give us a number (not controlled by us) of OpenGL textures per swapchain
   * and tell us with xrAcquireSwapchainImage, which of those we can render to per frame.
   * Here we use one swapchain per view (eye), and for example 3 ("triple buffering") images per
   * swapchain.
   */
  mSwapchains.resize(view_count);
 
  //if (!mFovMutable)
  //  mTextureBuffer.resize(view_count);
 
  // A stereo view config implies two views, but our code is set up for a dynamic amount of views.
  // So we need to allocate a bunch of memory for data structures dynamically.
  mProjectionViews.resize(view_count);
 
  for (uint32_t i = 0; i < view_count; i++)
  {
    XrSwapchainCreateInfo swapchain_create_info;
    swapchain_create_info.type = XR_TYPE_SWAPCHAIN_CREATE_INFO;
    swapchain_create_info.usageFlags = XR_SWAPCHAIN_USAGE_SAMPLED_BIT | XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT;
    swapchain_create_info.createFlags = 0;
    swapchain_create_info.format = swapchainFormat;
    swapchain_create_info.sampleCount = mViewconfigViews[i].recommendedSwapchainSampleCount;
    swapchain_create_info.width = static_cast<uint32_t>((float)mViewconfigViews[i].recommendedImageRectWidth * mScaleRatio);
    swapchain_create_info.height = static_cast<uint32_t>((float)mViewconfigViews[i].recommendedImageRectHeight * mScaleRatio);
    swapchain_create_info.faceCount = 1;
    swapchain_create_info.arraySize = 1;
    swapchain_create_info.mipCount = 1;
    swapchain_create_info.next = XR_NULL_HANDLE;
 
    result = xrCreateSwapchain(mSession, &swapchain_create_info, &mSwapchains[i]);
    if (!xr_result(mInstance, result, "Failed to create swapchain %d!", i))
    {
      xrDestroySession(mSession);
      xrDestroyInstance(mInstance);
      return false;
    }
 
    if (!mRenderer->CreateSwapchainImage(mInstance, view_count, mSwapchains[i], i))
    {
      xrDestroySession(mSession);
      xrDestroyInstance(mInstance);
      return false;
    }
    
    mProjectionViews[i].type = XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW;
    mProjectionViews[i].next = XR_NULL_HANDLE;
 
    mProjectionViews[i].subImage.swapchain = mSwapchains[i];
    mProjectionViews[i].subImage.imageArrayIndex = 0;
    mProjectionViews[i].subImage.imageRect.offset = { 0, 0 };
    mProjectionViews[i].subImage.imageRect.extent = { static_cast<int32_t>(swapchain_create_info.width), static_cast<int32_t>(swapchain_create_info.height) };
 
    // projection_views[i].pose (and fov) have to be filled every frame in frame loop
  }
 
  uint32_t blendCount;
  result = xrEnumerateEnvironmentBlendModes(mInstance, mSystemId, mViewType, 0, &blendCount, nullptr);
 
  if (blendCount > 0)
  {
    std::set<XrEnvironmentBlendMode> lookForBlendModes{ XR_ENVIRONMENT_BLEND_MODE_OPAQUE, XR_ENVIRONMENT_BLEND_MODE_ADDITIVE, XR_ENVIRONMENT_BLEND_MODE_ALPHA_BLEND };
    std::vector<XrEnvironmentBlendMode> blendModes(blendCount);
    result = xrEnumerateEnvironmentBlendModes(mInstance, mSystemId, mViewType, blendCount, &blendCount, blendModes.data());
 
    for (const auto& blendMode : blendModes)
    {
      if (mBlendMode == blendMode)
        break;
      else if (lookForBlendModes.count(blendMode))
        mBlendMode = blendMode;
    }
  }
 
  if (!initControllers())
  {
    xrDestroySession(mSession);
    xrDestroyInstance(mInstance);
    return false;
  }
 
  // Create the Passthrough feature
  createPassthrough();
 
  return true;
}
 
void sOpenXr::cleanup()
{
  XrResult result;
 
  if (mInstance != XR_NULL_HANDLE)
  {
    if (mSession != XR_NULL_HANDLE)
      xrEndSession(mSession);
 
    if (mHandTracking.system_supported)
    {
      PFN_xrDestroyHandTrackerEXT pfnDestroyHandTrackerEXT = XR_NULL_HANDLE;
      result = xrGetInstanceProcAddr(mInstance, "xrDestroyHandTrackerEXT", (PFN_xrVoidFunction*)&pfnDestroyHandTrackerEXT);
      if (xr_result(mInstance, result, "Failed to get xrDestroyHandTrackerEXT function!"))
      {
        if (mHandTracking.trackers[VrController::Left])
        {
          result = pfnDestroyHandTrackerEXT(mHandTracking.trackers[VrController::Left]);
          if (xr_result(mInstance, result, "Failed to destroy left hand tracker"))
            MMechostr(MSKRUNTIME, "[OPENXR]: Destroyed hand tracker for left hand\n");
        }
 
        if (mHandTracking.trackers[VrController::Right])
        {
          result = pfnDestroyHandTrackerEXT(mHandTracking.trackers[VrController::Right]);
          if (xr_result(mInstance, result, "Failed to destroy left hand tracker"))
            MMechostr(MSKRUNTIME, "[OPENXR]: Destroyed hand tracker for left hand\n");
        }
      }
    }
 
    cleanPassthrough();
 
    if (mInput.actionSet != XR_NULL_HANDLE)
    {
      for (auto hand : { VrController::Left, VrController::Right })
        xrDestroySpace(mInput.handSpace[hand]);
 
      xrDestroyActionSet(mInput.actionSet);
    }
 
    xrDestroySpace(mPlaySpace);
    xrDestroySpace(mViewSpace);
 
    if (mSession != XR_NULL_HANDLE)
    {
      xrDestroySession(mSession);
      mSession = XR_NULL_HANDLE;
    }
  }
 
  if (mInstance != XR_NULL_HANDLE)
  {
    xrDestroyInstance(mInstance);
    mInstance = XR_NULL_HANDLE;
  }
  mPoseValid = false;
}
 
void sOpenXr::printSupportedViewConfigs()
{
  XrResult result;
 
  uint32_t view_config_count;
  result = xrEnumerateViewConfigurations(mInstance, mSystemId, 0, &view_config_count, XR_NULL_HANDLE);
  if (!xr_result(mInstance, result, "Failed to get view configuration count"))
    return;
 
  MMechostr(MSKRUNTIME, "[OPENXR]: Runtime supports %d view configurations", view_config_count);
 
  std::vector<XrViewConfigurationType> view_configs(view_config_count);
  result = xrEnumerateViewConfigurations(mInstance, mSystemId, view_config_count, &view_config_count, view_configs.data());
  if (!xr_result(mInstance, result, "Failed to enumerate view configurations!"))
    return;
 
  MMechostr(MSKRUNTIME, "[OPENXR]: Runtime supports view configurations:\n");
  for (uint32_t i = 0; i < view_config_count; ++i)
  {
    XrViewConfigurationProperties props = { XR_TYPE_VIEW_CONFIGURATION_PROPERTIES, XR_NULL_HANDLE };
 
    result = xrGetViewConfigurationProperties(mInstance, mSystemId, view_configs[i], &props);
    if (!xr_result(mInstance, result, "Failed to get view configuration info %d!", i))
      return;
 
    //mFovMutable = props.fovMutable == XR_TRUE ? true : false;
    //std::cout << props.viewConfigurationType << ": FOV mutable: " << props.fovMutable << "\n";
  }
}
 
void sOpenXr::printViewconfigViewInfo()
{
  for (uint32_t i = 0; i < mViewconfigViews.size(); i++)
  {
    MMechostr(MSKRUNTIME, "[OPENXR]: View Configuration View %d:\n", i);
    MMechostr(MSKRUNTIME, "\tResolution       : Recommended %dx%d, Max: %dx%d\n",
      mViewconfigViews[0].recommendedImageRectWidth,
      mViewconfigViews[0].recommendedImageRectHeight,
      mViewconfigViews[0].maxImageRectWidth,
      mViewconfigViews[0].maxImageRectHeight);
    MMechostr(MSKRUNTIME, "\tSwapchain Samples: Recommended: %d, Max: %d)\n",
      mViewconfigViews[0].recommendedSwapchainSampleCount,
      mViewconfigViews[0].maxSwapchainSampleCount);
  }
}
 
void sOpenXr::printReferenceSpaces()
{
  XrResult result;
 
  uint32_t ref_space_count;
  result = xrEnumerateReferenceSpaces(mSession, 0, &ref_space_count, XR_NULL_HANDLE);
  if (!xr_result(mInstance, result, "Getting number of reference spaces failed!"))
    return;
 
  std::vector<XrReferenceSpaceType> ref_spaces(ref_space_count);
  result = xrEnumerateReferenceSpaces(mSession, ref_space_count, &ref_space_count, ref_spaces.data());
  if (!xr_result(mInstance, result, "Enumerating reference spaces failed!"))
    return;
 
  MMechostr(MSKRUNTIME, "[OPENXR]: Runtime supports %d reference spaces:\n", ref_space_count);
  for (uint32_t i = 0; i < ref_space_count; i++) {
    if (ref_spaces[i] == XR_REFERENCE_SPACE_TYPE_LOCAL) {
      MMechostr(MSKRUNTIME, "\tXR_REFERENCE_SPACE_TYPE_LOCAL\n");
    }
    else if (ref_spaces[i] == XR_REFERENCE_SPACE_TYPE_STAGE) {
      MMechostr(MSKRUNTIME, "\tXR_REFERENCE_SPACE_TYPE_STAGE\n");
    }
    else if (ref_spaces[i] == XR_REFERENCE_SPACE_TYPE_VIEW) {
      MMechostr(MSKRUNTIME, "\tXR_REFERENCE_SPACE_TYPE_VIEW\n");
    }
    else {
      MMechostr(MSKRUNTIME, "\tOther (extension?) refspace %u\\n", ref_spaces[i]);
    }
  }
}
 
 
sOpenXr* sOpenXr::CreateInstance(RenderSystem rsys, float scale)
{
  if (NULL == _singleton)
  {
    _singleton = new sOpenXr(rsys, scale);
  }
  else
  {
    _singleton->SetRenderer(rsys);
    _singleton->SetScaleRatio(scale);
  }
 
  return _singleton;
}
 
sOpenXr* sOpenXr::GetInstance()
{
  if (NULL == _singleton)
    _singleton = new sOpenXr();
 
  return _singleton;
}
 
void sOpenXr::Kill()
{
  SAFE_DELETE(_singleton);
}
 
RenderSystem sOpenXr::GetRenderer()
{
  return mRendererType;
}
 
void sOpenXr::SetScaleRatio(float ratio)
{
  if (mScaleRatio != ratio)
  {
    mScaleRatio = ratio;
    if (mConnected)
    {
      Disconnect();
      Connect();
    }
  }
}
 
XrInstance sOpenXr::GetXrInstance()
{
  return mInstance;
}
 
XrSession sOpenXr::GetXrSession()
{
  return mSession;
}
 
bool sOpenXr::IsConnected()
{
  return mConnected;
}
 
bool sOpenXr::Connect()
{
  if (mConnected)
    return false;
 
  mConnected = initialize();
 
  if (!mConnected)
    return false;
 
  return true;
}
 
std::string sOpenXr::GetHmdName()
{
  if (!mConnected)
    return "";
 
  return mDeviceName;
}
 
void sOpenXr::Disconnect()
{
  if (mConnected)
  {
    mConnected = false;
  }
 
  cleanup();
}
 
void sOpenXr::SetState(bool state)
{
  mPaused = !state;
 
  //hack to restore passthrough after a system pause
  if (mPassthroughEnable)
  {
    mPassthroughEnable = false;
    updatePassthrough();
    mPassthroughEnable = true;
    updatePassthrough();
  }
}
 
bool sOpenXr::IsVisible()
{
  return (!mPaused && (mState == XR_SESSION_STATE_VISIBLE || mState == XR_SESSION_STATE_FOCUSED)) ? true : false;
}
 
bool sOpenXr::GetHmdOrientation(Quaternion &quat)
{
  if (!mConnected || !mPoseValid)
    return false;
 
  quat = mPreviousHmdQuat;
  return true;
}
 
bool sOpenXr::GetHmdPosition(Vector3 &vec)
{
  if (!mConnected || !mPoseValid)
    return false;
 
  vec = mPreviousHmdPos;
  return true;
}
 
bool sOpenXr::GetProjectionMatrix(VrEye eye, float nearclip, float farclip, Matrix4 &mat)
{
  if (!mConnected || !mPoseValid)
    return false;
 
  XrMatrix4x4f proj;
  XrMatrix4x4f_CreateProjectionFov(&proj, GRAPHICS_OPENGL, mViews[eye].fov, nearclip, farclip);
  mat = Matrix4(proj);
  return true;
}
 
bool sOpenXr::GetStereoTextureSize(unsigned int &w, unsigned int &h)
{
  if (!mConnected)
    return false;
 
  // scale a bit for better quality
  w = (unsigned int)(mViewconfigViews[1].recommendedImageRectWidth * mScaleRatio);
  h = (unsigned int)(mViewconfigViews[1].recommendedImageRectHeight * mScaleRatio);
 
  return true;
}
 
float sOpenXr::GetStereoConfigFovY()
{
  if (!mConnected || !mPoseValid)
    return vrRadiansFromDegrees(90.0f);
 
  float fovX = 0.0f;
  float fovY = 0.0f;
 
  XrFovInRadians(fovX, fovY, GRAPHICS_OPENGL, mViews[0].fov);
 
  return fovY;
}
 
float sOpenXr::GetStereoConfigIPD()
{
  return mLastIPD;
}
 
XrTime sOpenXr::GetPredictedDisplayTime()
{
  return mPredictedDisplayTime;
}
 
bool sOpenXr::processEvents()
{
  XrEventDataBuffer runtime_event = { XR_TYPE_EVENT_DATA_BUFFER, XR_NULL_HANDLE };
  XrResult poll_result = xrPollEvent(mInstance, &runtime_event);
  XrResult result;
 
  while (poll_result == XR_SUCCESS)
  {
    switch (runtime_event.type)
    {
    case XR_TYPE_EVENT_DATA_EVENTS_LOST:
    {
      XrEventDataEventsLost* event = (XrEventDataEventsLost*)&runtime_event;
      MMechostr(MSKDEBUG, "[OPENXR]: EVENT: %d events data lost!\n", event->lostEventCount);
      // do we care if the runtime loses events?
      break;
    }
    case XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING:
    {
      XrEventDataInstanceLossPending* event = (XrEventDataInstanceLossPending*)&runtime_event;
      mRequestRestart = true;
      mSessionRunning = false;
      MMechostr(MSKDEBUG, "[OPENXR]: EVENT: instance loss pending at %lu! Destroying instance.\n", event->lossTime);
      break;
    }
    case XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED:
    {
      XrEventDataSessionStateChanged* event = (XrEventDataSessionStateChanged*)&runtime_event;
      MMechostr(MSKDEBUG, "[OPENXR]: EVENT: session state changed from %d to %d\n", mState, event->state);
 
      const XrSessionState oldState = mState;
      mState = event->state;
 
      if ((event->session != XR_NULL_HANDLE) && (event->session != mSession))
        break;
 
      switch (mState)
      {
      case XR_SESSION_STATE_READY:
      {
        if (mSession != XR_NULL_HANDLE)
        {
          XrSessionBeginInfo session_begin_info = { XR_TYPE_SESSION_BEGIN_INFO, XR_NULL_HANDLE, mViewType };
          result = xrBeginSession(mSession, &session_begin_info);
          if (!xr_result(mInstance, result, "Failed to begin session!"))
            return false;
 
          mSessionRunning = true;
          MMechostr(MSKRUNTIME, "[OPENXR]: Session started!\n");
        }
        break;
      }
      case XR_SESSION_STATE_STOPPING:
      {
        if (mSession != XR_NULL_HANDLE)
        {
          mSessionRunning = false;
          xrEndSession(mSession);
        }
        break;
      }
      case XR_SESSION_STATE_EXITING:
      {
        mRequestRestart = false;
        break;
      }
      case XR_SESSION_STATE_LOSS_PENDING:
      {
        // Poll for a new instance.
        mRequestRestart = true;
        break;
      }
      default:
        break;
      }
      break;
    }
    case XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING:
    {
      MMechostr(MSKDEBUG, "[OPENXR]: EVENT: reference space change pending!\n");
      XrEventDataReferenceSpaceChangePending* event = (XrEventDataReferenceSpaceChangePending*)&runtime_event;
      (void)event;
      // TODO: do something
      break;
    }
    case XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED:
    {
      MMechostr(MSKDEBUG, "[OPENXR]: EVENT: interaction profile changed!\n");
      XrEventDataInteractionProfileChanged* event = (XrEventDataInteractionProfileChanged*)&runtime_event;
      (void)event;
 
      XrInteractionProfileState state = { XR_TYPE_INTERACTION_PROFILE_STATE };
 
      for (int i = 0; i < MAX_VR_CONTROLLERS; i++)
      {
        XrResult res = xrGetCurrentInteractionProfile(mSession, mInput.handSubactionPath[i], &state);
        if (!xr_result(mInstance, res, "Failed to get interaction profile for %d", i))
          continue;
 
        if (state.interactionProfile != XR_NULL_PATH)
        {
          uint32_t strl;
          char profile_str[XR_MAX_PATH_LENGTH];
          res = xrPathToString(mInstance, state.interactionProfile, XR_MAX_PATH_LENGTH, &strl, profile_str);
          if (!xr_result(mInstance, res, "Failed to get interaction profile path str"))
            continue;
          
          if (std::string(profile_str) == "/interaction_profiles/khr/simple_controller")
            mLastControllerType = ControllerType::CLASSIC_CONTROLLER;
          else if (std::string(profile_str) == "/interaction_profiles/htc/vive_controller")
            mLastControllerType = ControllerType::HTCVIVE_CONTROLLER;
          else if (std::string(profile_str) == "/interaction_profiles/valve/index_controller")
            mLastControllerType = ControllerType::VALVE_INDEX_CONTROLLER;
          else if (std::string(profile_str) == "/interaction_profiles/bytedance/pico4_controller")
            mLastControllerType = ControllerType::PICO_PICO4_CONTROLLER;
          else if ((std::string(profile_str) == "/interaction_profiles/pico/neo3_controller") || (std::string(profile_str) == "/interaction_profiles/bytedance/pico_neo3_controller") || mIsPico)
            mLastControllerType = ControllerType::PICO_NEO3_CONTROLLER;
          else if (std::string(profile_str) == "/interaction_profiles/oculus/touch_controller")
            mLastControllerType = ControllerType::OCULUS_TOUCH_CONTROLLER;
          else if (std::string(profile_str) == "/interaction_profiles/microsoft/motion_controller")
            mLastControllerType = ControllerType::MS_MOTION_CONTROLLER;
          else
            mLastControllerType = ControllerType::CLASSIC_CONTROLLER;
          
          MMechostr(MSKDEBUG, "[OPENXR]: Event: Interaction profile changed to %s\n", profile_str);
        }
      }
      break;
    }
 
    case XR_TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR:
    {
      MMechostr(MSKDEBUG, "[OPENXR]: EVENT: visibility mask changed!!\n");
      XrEventDataVisibilityMaskChangedKHR* event = (XrEventDataVisibilityMaskChangedKHR*)&runtime_event;
      (void)event;
      // this event is from an extension
      break;
    }
    case XR_TYPE_EVENT_DATA_PERF_SETTINGS_EXT:
    {
      MMechostr(MSKDEBUG, "[OPENXR]: EVENT: perf settings!\n");
      XrEventDataPerfSettingsEXT* event = (XrEventDataPerfSettingsEXT*)&runtime_event;
      (void)event;
      // this event is from an extension
      break;
    }
    case XR_TYPE_EVENT_DATA_PASSTHROUGH_STATE_CHANGED_FB:
    {
      MMechostr(MSKDEBUG, "[OPENXR]: EVENT: passthroughFB state!\n");
      XrEventDataPassthroughStateChangedFB* event = (XrEventDataPassthroughStateChangedFB *)&runtime_event;
      if (event->flags & XR_PASSTHROUGH_STATE_CHANGED_REINIT_REQUIRED_BIT_FB )
      {
        cleanPassthrough();
        createPassthrough();
        mPassthroughFB.available = true;
        updatePassthrough();
      }
      else if (event->flags & XR_PASSTHROUGH_STATE_CHANGED_RESTORED_ERROR_BIT_FB)
      {
        mPassthroughFB.available = true;
        updatePassthrough();
      }
      else if (event->flags & XR_PASSTHROUGH_STATE_CHANGED_NON_RECOVERABLE_ERROR_BIT_FB || event->flags & XR_PASSTHROUGH_STATE_CHANGED_RECOVERABLE_ERROR_BIT_FB)
      {
        mPassthroughFB.available = false;
      }
      (void)event;
      break;
    }
    default: MMechostr(MSKDEBUG, "[OPENXR]: Unhandled event type %d\n", runtime_event.type);
    }
 
    runtime_event.type = XR_TYPE_EVENT_DATA_BUFFER;
    poll_result = xrPollEvent(mInstance, &runtime_event);
  }
 
  if (poll_result == XR_EVENT_UNAVAILABLE)
  {
    // processed all events in the queue
    return true;
  }
  else
  {
    MMechostr(MSKRUNTIME, "[OPENXR]: Failed to poll events!\n");
    return false;
  }
}
 
void sOpenXr::processActions()
{
  if (mState != XR_SESSION_STATE_FOCUSED)
    return;
 
  XrResult result;
 
  // Sync actions
  const XrActiveActionSet activeActionSet{ mInput.actionSet, XR_NULL_PATH };
  XrActionsSyncInfo syncInfo{ XR_TYPE_ACTIONS_SYNC_INFO, XR_NULL_HANDLE, 1, &activeActionSet };
  result = xrSyncActions(mSession, &syncInfo);
  xr_result(mInstance, result, "failed to sync actions!");
 
  // Get pose and grab action state and start haptic vibrate when hand is 90% squeezed.
  for (auto hand : { VrController::Left, VrController::Right })
  {
    XrActionStateGetInfo getInfo{ XR_TYPE_ACTION_STATE_GET_INFO };
    getInfo.subactionPath = mInput.handSubactionPath[hand];
 
    unsigned int iact = 0;
    for (auto act : mInput.buttonAction)
    {
      if (act != 0)
      {
        getInfo.action = act;
        XrActionStateBoolean btnState{ XR_TYPE_ACTION_STATE_BOOLEAN };
        btnState.currentState = XR_FALSE;
        result = xrGetActionStateBoolean(mSession, &getInfo, &btnState);
        mInput.buttonStates[hand][iact] = btnState.currentState == XR_TRUE ? true : false;
      }
      iact++;
    }
 
    iact = 0;
    for (auto act : mInput.analogAction)
    {
      if (act != 0)
      {
        getInfo.action = act;
        XrActionStateFloat analogState{ XR_TYPE_ACTION_STATE_FLOAT };
        analogState.currentState = 0.0;
        result = xrGetActionStateFloat(mSession, &getInfo, &analogState);
 
        // send axis when button is clicked for HTC vive
        if ((mLastControllerType == HTCVIVE_CONTROLLER) && ((iact == analogPadX) || (iact == analogPadY)) && !mInput.buttonStates[hand][(hand == VrController::Left) ? btnLThumb : btnRThumb])
          mInput.analogStates[hand][iact] = 0.0;
        else
          mInput.analogStates[hand][iact] = analogState.currentState;
      }
      iact++;
    }
 
    iact = 0;
    for (auto act : mInput.touchAction)
    {
      if (act != 0)
      {
        getInfo.action = act;
        XrActionStateBoolean touchState{ XR_TYPE_ACTION_STATE_BOOLEAN };
        touchState.currentState = XR_FALSE;
        result = xrGetActionStateBoolean(mSession, &getInfo, &touchState);
 
        mInput.touchStates[hand][iact] = touchState.currentState == XR_TRUE ? true : false;
      }
 
      iact++;
    }
 
    //manage gestures from combinations
    if (hand == VrController::Left)
      mInput.touchStates[hand][ControllerTouch::touchThumbUp] = (!mInput.touchStates[hand][ControllerTouch::touchThumbUp] &&
        !mInput.touchStates[hand][ControllerTouch::touchLThumb] &&
        !mInput.touchStates[hand][ControllerTouch::touchX] &&
        !mInput.touchStates[hand][ControllerTouch::touchY]
        ) ? true : false;
    else
      mInput.touchStates[hand][ControllerTouch::touchThumbUp] = (!mInput.touchStates[hand][ControllerTouch::touchThumbUp] &&
        !mInput.touchStates[hand][ControllerTouch::touchRThumb] &&
        !mInput.touchStates[hand][ControllerTouch::touchA] &&
        !mInput.touchStates[hand][ControllerTouch::touchB]
        ) ? true : false;
 
    //Index pointing
    if (mLastControllerType == HTCVIVE_CONTROLLER)
      mInput.touchStates[hand][ControllerTouch::touchIndexPointing] = (mInput.analogStates[hand][ControllerAnalog::analogTrigger] == 0.0f && mInput.analogStates[hand][ControllerAnalog::analogGrip] > 0.0f) ? true : false;
    else
      mInput.touchStates[hand][ControllerTouch::touchIndexPointing] = (!mInput.touchStates[hand][ControllerTouch::touchTrigger] && mInput.analogStates[hand][ControllerAnalog::analogGrip] > 0.0f) ? true : false;
 
    getInfo.action = mInput.poseAction;
    XrActionStatePose poseState{ XR_TYPE_ACTION_STATE_POSE };
    result = xrGetActionStatePose(mSession, &getInfo, &poseState);
    mInput.handActive[hand] = poseState.isActive;
  }
 
}
 
bool sOpenXr::initControllers()
{
  XrResult result;
  // Create an action set.
  {
    XrActionSetCreateInfo actionSetInfo{ XR_TYPE_ACTION_SET_CREATE_INFO };
    strcpy_s(actionSetInfo.actionSetName, "gameplay");
    strcpy_s(actionSetInfo.localizedActionSetName, "Gameplay");
    actionSetInfo.priority = 0;
    result = xrCreateActionSet(mInstance, &actionSetInfo, &mInput.actionSet);
    if (!xr_result(mInstance, result, "failed to creates actionset!"))
      return false;
  }
 
  // Get the XrPath for the left and right hands - we will use them as subaction paths.
  xrStringToPath(mInstance, "/user/hand/left", &mInput.handSubactionPath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right", &mInput.handSubactionPath[VrController::Right]);
 
  mInput.handVisible[VrController::Left] = false;
  mInput.handVisible[VrController::Right] = false;
 
  mInput.buttonAction.resize(ControllerButtons::btnSize, XrAction{ XR_NULL_HANDLE });
  mInput.touchAction.resize(ControllerTouch::touchSize, XrAction{ XR_NULL_HANDLE });
  mInput.analogAction.resize(ControllerAnalog::analogSize, XrAction{ XR_NULL_HANDLE });
 
  mInput.buttonStates.resize(MAX_VR_CONTROLLERS);
  mInput.touchStates.resize(MAX_VR_CONTROLLERS);
  mInput.analogStates.resize(MAX_VR_CONTROLLERS);
  for (auto hand : { VrController::Left, VrController::Right })
  {
    mInput.buttonStates[hand].resize(mInput.buttonAction.size(), false);
    mInput.touchStates[hand].resize(mInput.touchAction.size(), false);
    mInput.analogStates[hand].resize(mInput.analogAction.size(), 0.0f);
  }
 
  // Create actions.
  // Create an input action for grabbing objects with the left and right hands.
  XrActionCreateInfo actionInfo{ XR_TYPE_ACTION_CREATE_INFO };
  actionInfo.actionType = XR_ACTION_TYPE_BOOLEAN_INPUT;
  strcpy_s(actionInfo.actionName, "a_button");
  strcpy_s(actionInfo.localizedActionName, "A Button");
  actionInfo.countSubactionPaths = 1;
  actionInfo.subactionPaths = &mInput.handSubactionPath[VrController::Right];
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.buttonAction[ControllerButtons::btnA]);
  if (!xr_result(mInstance, result, "failed to creates A Button action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_BOOLEAN_INPUT;
  strcpy_s(actionInfo.actionName, "a_touch");
  strcpy_s(actionInfo.localizedActionName, "A Touch");
  actionInfo.countSubactionPaths = 1;
  actionInfo.subactionPaths = &mInput.handSubactionPath[VrController::Right];
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.touchAction[ControllerTouch::touchA]);
  if (!xr_result(mInstance, result, "failed to creates A Touch action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_BOOLEAN_INPUT;
  strcpy_s(actionInfo.actionName, "b_button");
  strcpy_s(actionInfo.localizedActionName, "B Button");
  actionInfo.countSubactionPaths = 1;
  actionInfo.subactionPaths = &mInput.handSubactionPath[VrController::Right];
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.buttonAction[ControllerButtons::btnB]);
  if (!xr_result(mInstance, result, "failed to creates B Button action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_BOOLEAN_INPUT;
  strcpy_s(actionInfo.actionName, "b_touch");
  strcpy_s(actionInfo.localizedActionName, "B Touch");
  actionInfo.countSubactionPaths = 1;
  actionInfo.subactionPaths = &mInput.handSubactionPath[VrController::Right];
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.touchAction[ControllerTouch::touchB]);
  if (!xr_result(mInstance, result, "failed to creates B Touch action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_BOOLEAN_INPUT;
  strcpy_s(actionInfo.actionName, "x_button");
  strcpy_s(actionInfo.localizedActionName, "X Button");
  actionInfo.countSubactionPaths = 1;
  actionInfo.subactionPaths = &mInput.handSubactionPath[VrController::Left];
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.buttonAction[ControllerButtons::btnX]);
  if (!xr_result(mInstance, result, "failed to creates X Button action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_BOOLEAN_INPUT;
  strcpy_s(actionInfo.actionName, "x_touch");
  strcpy_s(actionInfo.localizedActionName, "X Touch");
  actionInfo.countSubactionPaths = 1;
  actionInfo.subactionPaths = &mInput.handSubactionPath[VrController::Left];
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.touchAction[ControllerTouch::touchX]);
  if (!xr_result(mInstance, result, "failed to creates X Touch action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_BOOLEAN_INPUT;
  strcpy_s(actionInfo.actionName, "y_button");
  strcpy_s(actionInfo.localizedActionName, "Y Button");
  actionInfo.countSubactionPaths = 1;
  actionInfo.subactionPaths = &mInput.handSubactionPath[VrController::Left];
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.buttonAction[ControllerButtons::btnY]);
  if (!xr_result(mInstance, result, "failed to creates Y Button action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_BOOLEAN_INPUT;
  strcpy_s(actionInfo.actionName, "y_touch");
  strcpy_s(actionInfo.localizedActionName, "Y Touch");
  actionInfo.countSubactionPaths = 1;
  actionInfo.subactionPaths = &mInput.handSubactionPath[VrController::Left];
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.touchAction[ControllerTouch::touchY]);
  if (!xr_result(mInstance, result, "failed to creates Y Touch action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_BOOLEAN_INPUT;
  strcpy_s(actionInfo.actionName, "rthumb_button");
  strcpy_s(actionInfo.localizedActionName, "Right Thumb Button");
  actionInfo.countSubactionPaths = 1;
  actionInfo.subactionPaths = &mInput.handSubactionPath[VrController::Right];
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.buttonAction[ControllerButtons::btnRThumb]);
  if (!xr_result(mInstance, result, "failed to creates Right Thumb Button action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_BOOLEAN_INPUT;
  strcpy_s(actionInfo.actionName, "rthumb_touch");
  strcpy_s(actionInfo.localizedActionName, "Right Thumb Touch");
  actionInfo.countSubactionPaths = 1;
  actionInfo.subactionPaths = &mInput.handSubactionPath[VrController::Right];
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.touchAction[ControllerTouch::touchRThumb]);
  if (!xr_result(mInstance, result, "failed to creates Right Thumb Button action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_BOOLEAN_INPUT;
  strcpy_s(actionInfo.actionName, "lthumb_button");
  strcpy_s(actionInfo.localizedActionName, "Left Thumb Button");
  actionInfo.countSubactionPaths = 1;
  actionInfo.subactionPaths = &mInput.handSubactionPath[VrController::Left];
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.buttonAction[ControllerButtons::btnLThumb]);
  if (!xr_result(mInstance, result, "failed to creates Left Thumb action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_BOOLEAN_INPUT;
  strcpy_s(actionInfo.actionName, "lthumb_touch");
  strcpy_s(actionInfo.localizedActionName, "Left Thumb Touch");
  actionInfo.countSubactionPaths = 1;
  actionInfo.subactionPaths = &mInput.handSubactionPath[VrController::Left];
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.touchAction[ControllerTouch::touchLThumb]);
  if (!xr_result(mInstance, result, "failed to creates Left Thumb action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_BOOLEAN_INPUT;
  strcpy_s(actionInfo.actionName, "thumbup_touch");
  strcpy_s(actionInfo.localizedActionName, "Thumbup Touch");
  actionInfo.countSubactionPaths = uint32_t(mInput.handSubactionPath.size());
  actionInfo.subactionPaths = mInput.handSubactionPath.data();
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.touchAction[ControllerTouch::touchThumbUp]);
  if (!xr_result(mInstance, result, "failed to creates Thumbup Touch action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_FLOAT_INPUT;
  strcpy_s(actionInfo.actionName, "thumbstick_x");
  strcpy_s(actionInfo.localizedActionName, "Thumbstick X value");
  actionInfo.countSubactionPaths = uint32_t(mInput.handSubactionPath.size());
  actionInfo.subactionPaths = mInput.handSubactionPath.data();
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.analogAction[ControllerAnalog::analogPadX]);
  if (!xr_result(mInstance, result, "failed to creates Thumbstick X action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_FLOAT_INPUT;
  strcpy_s(actionInfo.actionName, "thumbstick_y");
  strcpy_s(actionInfo.localizedActionName, "Thumbstick Y value");
  actionInfo.countSubactionPaths = uint32_t(mInput.handSubactionPath.size());
  actionInfo.subactionPaths = mInput.handSubactionPath.data();
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.analogAction[ControllerAnalog::analogPadY]);
  if (!xr_result(mInstance, result, "failed to creates Thumbstick Y action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_BOOLEAN_INPUT;
  strcpy_s(actionInfo.actionName, "grip_button");
  strcpy_s(actionInfo.localizedActionName, "Grip Button");
  actionInfo.countSubactionPaths = uint32_t(mInput.handSubactionPath.size());
  actionInfo.subactionPaths = mInput.handSubactionPath.data();
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.buttonAction[ControllerButtons::btnGrip]);
  if (!xr_result(mInstance, result, "failed to creates Grip Button action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_FLOAT_INPUT;
  strcpy_s(actionInfo.actionName, "grip_value");
  strcpy_s(actionInfo.localizedActionName, "Grip Value");
  actionInfo.countSubactionPaths = uint32_t(mInput.handSubactionPath.size());
  actionInfo.subactionPaths = mInput.handSubactionPath.data();
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.analogAction[ControllerAnalog::analogGrip]);
  if (!xr_result(mInstance, result, "failed to creates Grip Value action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_BOOLEAN_INPUT;
  strcpy_s(actionInfo.actionName, "trigger_button");
  strcpy_s(actionInfo.localizedActionName, "Trigger Button");
  actionInfo.countSubactionPaths = uint32_t(mInput.handSubactionPath.size());
  actionInfo.subactionPaths = mInput.handSubactionPath.data();
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.buttonAction[ControllerButtons::btnTrigger]);
  if (!xr_result(mInstance, result, "failed to creates Trigger Button action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_BOOLEAN_INPUT;
  strcpy_s(actionInfo.actionName, "trigger_touch");
  strcpy_s(actionInfo.localizedActionName, "Trigger Touch");
  actionInfo.countSubactionPaths = uint32_t(mInput.handSubactionPath.size());
  actionInfo.subactionPaths = mInput.handSubactionPath.data();
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.touchAction[ControllerTouch::touchTrigger]);
  if (!xr_result(mInstance, result, "failed to creates Trigger Touch action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_FLOAT_INPUT;
  strcpy_s(actionInfo.actionName, "trigger_value");
  strcpy_s(actionInfo.localizedActionName, "Trigger Value");
  actionInfo.countSubactionPaths = uint32_t(mInput.handSubactionPath.size());
  actionInfo.subactionPaths = mInput.handSubactionPath.data();
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.analogAction[ControllerAnalog::analogTrigger]);
  if (!xr_result(mInstance, result, "failed to creates Trigger Value action!"))
    return false;
 
  actionInfo.actionType = XR_ACTION_TYPE_BOOLEAN_INPUT;
  strcpy_s(actionInfo.actionName, "menu_button");
  strcpy_s(actionInfo.localizedActionName, "Menu Button");
  actionInfo.countSubactionPaths = uint32_t(mInput.handSubactionPath.size());
  actionInfo.subactionPaths = mInput.handSubactionPath.data();
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.buttonAction[ControllerButtons::btnMenu]);
  if (!xr_result(mInstance, result, "failed to creates Menu Button action!"))
    return false;
 
  // Create an input action getting the left and right hand poses.
  actionInfo.actionType = XR_ACTION_TYPE_POSE_INPUT;
  strcpy_s(actionInfo.actionName, "hand_pose");
  strcpy_s(actionInfo.localizedActionName, "Hand Pose");
  actionInfo.countSubactionPaths = uint32_t(mInput.handSubactionPath.size());
  actionInfo.subactionPaths = mInput.handSubactionPath.data();
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.poseAction);
  if (!xr_result(mInstance, result, "failed to creates pose action!"))
    return false;
 
  // Create output actions for vibrating the left and right controller.
  actionInfo.actionType = XR_ACTION_TYPE_VIBRATION_OUTPUT;
  strcpy_s(actionInfo.actionName, "vibrate_hand");
  strcpy_s(actionInfo.localizedActionName, "Vibrate Hand");
  actionInfo.countSubactionPaths = uint32_t(mInput.handSubactionPath.size());
  actionInfo.subactionPaths = mInput.handSubactionPath.data();
  result = xrCreateAction(mInput.actionSet, &actionInfo, &mInput.vibrateAction);
  if (!xr_result(mInstance, result, "failed to creates vibrate action!"))
    return false;
 
  XrPath aClickPath;
  XrPath aTouchPath;
  XrPath bClickPath;
  XrPath bTouchPath;
 
  XrPath xClickPath;
  XrPath xTouchPath;
  XrPath yClickPath;
  XrPath yTouchPath;
 
  std::array<XrPath, MAX_VR_CONTROLLERS> thumbClickPath;
  std::array<XrPath, MAX_VR_CONTROLLERS> thumbTouchPath;
  std::array<XrPath, MAX_VR_CONTROLLERS> thumbRestPath;
 
  std::array<XrPath, MAX_VR_CONTROLLERS> squeezeValuePath;
  std::array<XrPath, MAX_VR_CONTROLLERS> squeezeClickPath;
  std::array<XrPath, MAX_VR_CONTROLLERS> triggerValuePath;
  std::array<XrPath, MAX_VR_CONTROLLERS> triggerTouchPath;
  std::array<XrPath, MAX_VR_CONTROLLERS> triggerClickPath;
 
  std::array<XrPath, MAX_VR_CONTROLLERS> trackpadXPath;
  std::array<XrPath, MAX_VR_CONTROLLERS> trackpadYPath;
  std::array<XrPath, MAX_VR_CONTROLLERS> trackpadTouchPath;
  std::array<XrPath, MAX_VR_CONTROLLERS> trackpadClickPath;
 
  std::array<XrPath, MAX_VR_CONTROLLERS> thumbStickXPath;
  std::array<XrPath, MAX_VR_CONTROLLERS> thumbStickYPath;
 
  std::array<XrPath, MAX_VR_CONTROLLERS> selectClickPath;
  std::array<XrPath, MAX_VR_CONTROLLERS> menuClickPath;
  std::array<XrPath, MAX_VR_CONTROLLERS> sysClickPath;
  std::array<XrPath, MAX_VR_CONTROLLERS> posePath;
  std::array<XrPath, MAX_VR_CONTROLLERS> hapticPath;
 
  xrStringToPath(mInstance, "/user/hand/right/input/a/click", &aClickPath);
  xrStringToPath(mInstance, "/user/hand/right/input/a/touch", &aTouchPath);
  xrStringToPath(mInstance, "/user/hand/right/input/b/click", &bClickPath);
  xrStringToPath(mInstance, "/user/hand/right/input/b/touch", &bTouchPath);
 
  xrStringToPath(mInstance, "/user/hand/left/input/x/click", &xClickPath);
  xrStringToPath(mInstance, "/user/hand/left/input/x/touch", &xTouchPath);
  xrStringToPath(mInstance, "/user/hand/left/input/y/click", &yClickPath);
  xrStringToPath(mInstance, "/user/hand/left/input/y/touch", &yTouchPath);
 
  xrStringToPath(mInstance, "/user/hand/left/input/thumbstick/click", &thumbClickPath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right/input/thumbstick/click", &thumbClickPath[VrController::Right]);
  xrStringToPath(mInstance, "/user/hand/left/input/thumbstick/touch", &thumbTouchPath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right/input/thumbstick/touch", &thumbTouchPath[VrController::Right]);
 
  xrStringToPath(mInstance, "/user/hand/left/input/thumbstick/x", &thumbStickXPath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right/input/thumbstick/x", &thumbStickXPath[VrController::Right]);
  xrStringToPath(mInstance, "/user/hand/left/input/thumbstick/y", &thumbStickYPath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right/input/thumbstick/y", &thumbStickYPath[VrController::Right]);
 
  xrStringToPath(mInstance, "/user/hand/left/input/thumbrest/touch", &thumbRestPath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right/input/thumbrest/touch", &thumbRestPath[VrController::Right]);
 
  xrStringToPath(mInstance, "/user/hand/left/input/squeeze/value", &squeezeValuePath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right/input/squeeze/value", &squeezeValuePath[VrController::Right]);
  xrStringToPath(mInstance, "/user/hand/left/input/squeeze/click", &squeezeClickPath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right/input/squeeze/click", &squeezeClickPath[VrController::Right]);
 
  xrStringToPath(mInstance, "/user/hand/left/input/trigger/value", &triggerValuePath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right/input/trigger/value", &triggerValuePath[VrController::Right]);
  xrStringToPath(mInstance, "/user/hand/left/input/trigger/touch", &triggerTouchPath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right/input/trigger/touch", &triggerTouchPath[VrController::Right]);
  xrStringToPath(mInstance, "/user/hand/left/input/trigger/click", &triggerClickPath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right/input/trigger/click", &triggerClickPath[VrController::Right]);
 
  xrStringToPath(mInstance, "/user/hand/left/input/trackpad/x", &trackpadXPath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right/input/trackpad/x", &trackpadXPath[VrController::Right]);
  xrStringToPath(mInstance, "/user/hand/left/input/trackpad/y", &trackpadYPath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right/input/trackpad/y", &trackpadYPath[VrController::Right]);
  xrStringToPath(mInstance, "/user/hand/left/input/trackpad/touch", &trackpadTouchPath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right/input/trackpad/touch", &trackpadTouchPath[VrController::Right]);
  xrStringToPath(mInstance, "/user/hand/left/input/trackpad/click", &trackpadClickPath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right/input/trackpad/click", &trackpadClickPath[VrController::Right]);
 
  xrStringToPath(mInstance, "/user/hand/left/input/select/click", &selectClickPath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right/input/select/click", &selectClickPath[VrController::Right]);
 
  xrStringToPath(mInstance, "/user/hand/left/input/menu/click", &menuClickPath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right/input/menu/click", &menuClickPath[VrController::Right]);
 
  xrStringToPath(mInstance, "/user/hand/left/input/system/click", &sysClickPath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right/input/system/click", &sysClickPath[VrController::Right]);
 
  xrStringToPath(mInstance, "/user/hand/left/input/grip/pose", &posePath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right/input/grip/pose", &posePath[VrController::Right]);
  xrStringToPath(mInstance, "/user/hand/left/output/haptic", &hapticPath[VrController::Left]);
  xrStringToPath(mInstance, "/user/hand/right/output/haptic", &hapticPath[VrController::Right]);
 
  // Suggest bindings for KHR Simple.
  {
    XrPath khrSimpleInteractionProfilePath;
    xrStringToPath(mInstance, "/interaction_profiles/khr/simple_controller", &khrSimpleInteractionProfilePath);
    std::vector<XrActionSuggestedBinding> bindings{ {
                                                    {mInput.buttonAction[ControllerButtons::btnTrigger], selectClickPath[VrController::Left]},
                                                    {mInput.buttonAction[ControllerButtons::btnTrigger], selectClickPath[VrController::Right]},
                                                    {mInput.buttonAction[ControllerButtons::btnMenu], menuClickPath[VrController::Left]},
                                                    {mInput.buttonAction[ControllerButtons::btnMenu], menuClickPath[VrController::Right]},
                                                    {mInput.poseAction, posePath[VrController::Left]},
                                                    {mInput.poseAction, posePath[VrController::Right]},
                                                    {mInput.vibrateAction, hapticPath[VrController::Left]},
                                                    {mInput.vibrateAction, hapticPath[VrController::Right]}} };
    XrInteractionProfileSuggestedBinding suggestedBindings{ XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING };
    suggestedBindings.interactionProfile = khrSimpleInteractionProfilePath;
    suggestedBindings.suggestedBindings = bindings.data();
    suggestedBindings.countSuggestedBindings = (uint32_t)bindings.size();
    result = xrSuggestInteractionProfileBindings(mInstance, &suggestedBindings);
    if (!xr_result(mInstance, result, "failed to suggest bindings"))
      return false;
  }
 
  // Suggest bindings for the Pico Controller.
  if (mPicoController.supported)
  {
    {
      XrPath picoInteractionProfilePath;
      xrStringToPath(mInstance, "/interaction_profiles/bytedance/pico_neo3_controller", &picoInteractionProfilePath);
      std::vector<XrActionSuggestedBinding> bindings{ {
                                                        {mInput.buttonAction[ControllerButtons::btnA], aClickPath},
                                                        {mInput.touchAction[ControllerTouch::touchA], aTouchPath},
                                                        {mInput.buttonAction[ControllerButtons::btnB], bClickPath},
                                                        {mInput.touchAction[ControllerTouch::touchB], bTouchPath},
                                                        {mInput.buttonAction[ControllerButtons::btnX], xClickPath},
                                                        {mInput.touchAction[ControllerTouch::touchX], xTouchPath},
                                                        {mInput.buttonAction[ControllerButtons::btnY], yClickPath},
                                                        {mInput.touchAction[ControllerTouch::touchY], yTouchPath},
 
                                                        {mInput.buttonAction[ControllerButtons::btnRThumb], thumbClickPath[VrController::Right]},
                                                        {mInput.buttonAction[ControllerButtons::btnLThumb], thumbClickPath[VrController::Left]},
                                                        {mInput.touchAction[ControllerTouch::touchRThumb], thumbTouchPath[VrController::Right]},
                                                        {mInput.touchAction[ControllerTouch::touchLThumb], thumbTouchPath[VrController::Left]},
                                                        {mInput.analogAction[ControllerAnalog::analogPadX], thumbStickXPath[VrController::Left]},
                                                        {mInput.analogAction[ControllerAnalog::analogPadX], thumbStickXPath[VrController::Right]},
                                                        {mInput.analogAction[ControllerAnalog::analogPadY], thumbStickYPath[VrController::Left]},
                                                        {mInput.analogAction[ControllerAnalog::analogPadY], thumbStickYPath[VrController::Right]},
 
                                                        {mInput.analogAction[ControllerAnalog::analogGrip], squeezeValuePath[VrController::Left]},
                                                        {mInput.analogAction[ControllerAnalog::analogGrip], squeezeValuePath[VrController::Right]},
                                                        {mInput.buttonAction[ControllerButtons::btnGrip], squeezeValuePath[VrController::Left]},
                                                        {mInput.buttonAction[ControllerButtons::btnGrip], squeezeValuePath[VrController::Right]},
 
                                                        {mInput.analogAction[ControllerAnalog::analogTrigger], triggerValuePath[VrController::Left]},
                                                        {mInput.analogAction[ControllerAnalog::analogTrigger], triggerValuePath[VrController::Right]},
                                                        {mInput.buttonAction[ControllerButtons::btnTrigger], triggerClickPath[VrController::Left]},
                                                        {mInput.buttonAction[ControllerButtons::btnTrigger], triggerClickPath[VrController::Right]},
                                                        {mInput.touchAction[ControllerTouch::touchTrigger], triggerTouchPath[VrController::Left]},
                                                        {mInput.touchAction[ControllerTouch::touchTrigger], triggerTouchPath[VrController::Right]},
 
                                                        {mInput.touchAction[ControllerTouch::touchThumbUp], thumbRestPath[VrController::Left]},
                                                        {mInput.touchAction[ControllerTouch::touchThumbUp], thumbRestPath[VrController::Right]},
 
                                                        {mInput.buttonAction[ControllerButtons::btnMenu], menuClickPath[VrController::Left]},
                                                        {mInput.buttonAction[ControllerButtons::btnMenu], menuClickPath[VrController::Right]},
                                                        {mInput.poseAction, posePath[VrController::Left]},
                                                        {mInput.poseAction, posePath[VrController::Right]},
                                                        {mInput.vibrateAction, hapticPath[VrController::Left]},
                                                        {mInput.vibrateAction, hapticPath[VrController::Right]}} };
 
      XrInteractionProfileSuggestedBinding suggestedBindings{ XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING };
      suggestedBindings.interactionProfile = picoInteractionProfilePath;
      suggestedBindings.suggestedBindings = bindings.data();
      suggestedBindings.countSuggestedBindings = (uint32_t)bindings.size();
      result = xrSuggestInteractionProfileBindings(mInstance, &suggestedBindings);
      if (result == XR_ERROR_PATH_UNSUPPORTED)
        MMechostr(MSKRUNTIME, "[OPENXR]: Runtime does not supports %s\n", "/interaction_profiles/pico/neo3_controller");
      else
        xr_result(mInstance, result, "failed to suggest bindings");
    }
 
    {
      XrPath picoInteractionProfilePath;
      xrStringToPath(mInstance, "/interaction_profiles/bytedance/pico4_controller", &picoInteractionProfilePath);
      std::vector<XrActionSuggestedBinding> bindings{ {
                                                        {mInput.buttonAction[ControllerButtons::btnA], aClickPath},
                                                        {mInput.touchAction[ControllerTouch::touchA], aTouchPath},
                                                        {mInput.buttonAction[ControllerButtons::btnB], bClickPath},
                                                        {mInput.touchAction[ControllerTouch::touchB], bTouchPath},
                                                        {mInput.buttonAction[ControllerButtons::btnX], xClickPath},
                                                        {mInput.touchAction[ControllerTouch::touchX], xTouchPath},
                                                        {mInput.buttonAction[ControllerButtons::btnY], yClickPath},
                                                        {mInput.touchAction[ControllerTouch::touchY], yTouchPath},
 
                                                        {mInput.buttonAction[ControllerButtons::btnRThumb], thumbClickPath[VrController::Right]},
                                                        {mInput.buttonAction[ControllerButtons::btnLThumb], thumbClickPath[VrController::Left]},
                                                        {mInput.touchAction[ControllerTouch::touchRThumb], thumbTouchPath[VrController::Right]},
                                                        {mInput.touchAction[ControllerTouch::touchLThumb], thumbTouchPath[VrController::Left]},
                                                        {mInput.analogAction[ControllerAnalog::analogPadX], thumbStickXPath[VrController::Left]},
                                                        {mInput.analogAction[ControllerAnalog::analogPadX], thumbStickXPath[VrController::Right]},
                                                        {mInput.analogAction[ControllerAnalog::analogPadY], thumbStickYPath[VrController::Left]},
                                                        {mInput.analogAction[ControllerAnalog::analogPadY], thumbStickYPath[VrController::Right]},
 
                                                        {mInput.analogAction[ControllerAnalog::analogGrip], squeezeValuePath[VrController::Left]},
                                                        {mInput.analogAction[ControllerAnalog::analogGrip], squeezeValuePath[VrController::Right]},
                                                        {mInput.buttonAction[ControllerButtons::btnGrip], squeezeValuePath[VrController::Left]},
                                                        {mInput.buttonAction[ControllerButtons::btnGrip], squeezeValuePath[VrController::Right]},
 
                                                        {mInput.analogAction[ControllerAnalog::analogTrigger], triggerValuePath[VrController::Left]},
                                                        {mInput.analogAction[ControllerAnalog::analogTrigger], triggerValuePath[VrController::Right]},
                                                        {mInput.buttonAction[ControllerButtons::btnTrigger], triggerClickPath[VrController::Left]},
                                                        {mInput.buttonAction[ControllerButtons::btnTrigger], triggerClickPath[VrController::Right]},
                                                        {mInput.touchAction[ControllerTouch::touchTrigger], triggerTouchPath[VrController::Left]},
                                                        {mInput.touchAction[ControllerTouch::touchTrigger], triggerTouchPath[VrController::Right]},
 
                                                        {mInput.touchAction[ControllerTouch::touchThumbUp], thumbRestPath[VrController::Left]},
                                                        {mInput.touchAction[ControllerTouch::touchThumbUp], thumbRestPath[VrController::Right]},
 
                                                        {mInput.buttonAction[ControllerButtons::btnMenu], menuClickPath[VrController::Left]},
                                                        {mInput.poseAction, posePath[VrController::Left]},
                                                        {mInput.poseAction, posePath[VrController::Right]},
                                                        {mInput.vibrateAction, hapticPath[VrController::Left]},
                                                        {mInput.vibrateAction, hapticPath[VrController::Right]}} };
 
      XrInteractionProfileSuggestedBinding suggestedBindings{ XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING };
      suggestedBindings.interactionProfile = picoInteractionProfilePath;
      suggestedBindings.suggestedBindings = bindings.data();
      suggestedBindings.countSuggestedBindings = (uint32_t)bindings.size();
      result = xrSuggestInteractionProfileBindings(mInstance, &suggestedBindings);
      if (result == XR_ERROR_PATH_UNSUPPORTED)
        MMechostr(MSKRUNTIME, "[OPENXR]: Runtime does not supports %s\n", "/interaction_profiles/bytedance/pico4_controller");
      else
        xr_result(mInstance, result, "failed to suggest bindings");
    }
  }
 
  // Suggest bindings for the Oculus Touch.
  {
    XrPath oculusTouchInteractionProfilePath;
    xrStringToPath(mInstance, "/interaction_profiles/oculus/touch_controller", &oculusTouchInteractionProfilePath);
    std::vector<XrActionSuggestedBinding> bindings{ {
                                                    {mInput.buttonAction[ControllerButtons::btnA], aClickPath},
                                                    {mInput.touchAction[ControllerTouch::touchA], aTouchPath},
                                                    {mInput.buttonAction[ControllerButtons::btnB], bClickPath},
                                                    {mInput.touchAction[ControllerTouch::touchB], bTouchPath},
                                                    {mInput.buttonAction[ControllerButtons::btnX], xClickPath},
                                                    {mInput.touchAction[ControllerTouch::touchX], xTouchPath},
                                                    {mInput.buttonAction[ControllerButtons::btnY], yClickPath},
                                                    {mInput.touchAction[ControllerTouch::touchY], yTouchPath},
 
                                                    {mInput.buttonAction[ControllerButtons::btnRThumb], thumbClickPath[VrController::Right]},
                                                    {mInput.buttonAction[ControllerButtons::btnLThumb], thumbClickPath[VrController::Left]},
                                                    {mInput.touchAction[ControllerTouch::touchRThumb], thumbTouchPath[VrController::Right]},
                                                    {mInput.touchAction[ControllerTouch::touchLThumb], thumbTouchPath[VrController::Left]},
                                                    {mInput.analogAction[ControllerAnalog::analogPadX], thumbStickXPath[VrController::Left]},
                                                    {mInput.analogAction[ControllerAnalog::analogPadX], thumbStickXPath[VrController::Right]},
                                                    {mInput.analogAction[ControllerAnalog::analogPadY], thumbStickYPath[VrController::Left]},
                                                    {mInput.analogAction[ControllerAnalog::analogPadY], thumbStickYPath[VrController::Right]},
 
                                                    {mInput.analogAction[ControllerAnalog::analogGrip], squeezeValuePath[VrController::Left]},
                                                    {mInput.analogAction[ControllerAnalog::analogGrip], squeezeValuePath[VrController::Right]},
                                                    {mInput.buttonAction[ControllerButtons::btnGrip], squeezeValuePath[VrController::Left]},
                                                    {mInput.buttonAction[ControllerButtons::btnGrip], squeezeValuePath[VrController::Right]},
 
                                                    {mInput.analogAction[ControllerAnalog::analogTrigger], triggerValuePath[VrController::Left]},
                                                    {mInput.analogAction[ControllerAnalog::analogTrigger], triggerValuePath[VrController::Right]},
                                                    {mInput.buttonAction[ControllerButtons::btnTrigger], triggerValuePath[VrController::Left]},
                                                    {mInput.buttonAction[ControllerButtons::btnTrigger], triggerValuePath[VrController::Right]},
                                                    {mInput.touchAction[ControllerTouch::touchTrigger], triggerTouchPath[VrController::Left]},
                                                    {mInput.touchAction[ControllerTouch::touchTrigger], triggerTouchPath[VrController::Right]},
 
                                                    {mInput.touchAction[ControllerTouch::touchThumbUp], thumbRestPath[VrController::Left]},
                                                    {mInput.touchAction[ControllerTouch::touchThumbUp], thumbRestPath[VrController::Right]},
 
                                                    {mInput.buttonAction[ControllerButtons::btnMenu], menuClickPath[VrController::Left]},
                                                    {mInput.poseAction, posePath[VrController::Left]},
                                                    {mInput.poseAction, posePath[VrController::Right]},
                                                    {mInput.vibrateAction, hapticPath[VrController::Left]},
                                                    {mInput.vibrateAction, hapticPath[VrController::Right]}} };
 
    XrInteractionProfileSuggestedBinding suggestedBindings{ XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING };
    suggestedBindings.interactionProfile = oculusTouchInteractionProfilePath;
    suggestedBindings.suggestedBindings = bindings.data();
    suggestedBindings.countSuggestedBindings = (uint32_t)bindings.size();
    result = xrSuggestInteractionProfileBindings(mInstance, &suggestedBindings);
    if (result == XR_ERROR_PATH_UNSUPPORTED)
      MMechostr(MSKRUNTIME, "[OPENXR]: Runtime does not supports %s\n", "/interaction_profiles/oculus/touch_controller");
    else
      xr_result(mInstance, result, "failed to suggest bindings");
  }
 
  // Suggest bindings for the Vive Controller.
  {
    XrPath viveControllerInteractionProfilePath;
    xrStringToPath(mInstance, "/interaction_profiles/htc/vive_controller", &viveControllerInteractionProfilePath);
    std::vector<XrActionSuggestedBinding> bindings{ {
                                                    {mInput.buttonAction[ControllerButtons::btnRThumb], trackpadClickPath[VrController::Right]},
                                                    {mInput.buttonAction[ControllerButtons::btnLThumb], trackpadClickPath[VrController::Left]},
                                                    {mInput.touchAction[ControllerTouch::touchRThumb], trackpadTouchPath[VrController::Right]},
                                                    {mInput.touchAction[ControllerTouch::touchLThumb], trackpadTouchPath[VrController::Left]},
                                                    {mInput.analogAction[ControllerAnalog::analogPadX], trackpadXPath[VrController::Left]},
                                                    {mInput.analogAction[ControllerAnalog::analogPadX], trackpadXPath[VrController::Right]},
                                                    {mInput.analogAction[ControllerAnalog::analogPadY], trackpadYPath[VrController::Left]},
                                                    {mInput.analogAction[ControllerAnalog::analogPadY], trackpadYPath[VrController::Right]},
 
                                                    {mInput.buttonAction[ControllerButtons::btnGrip], squeezeClickPath[VrController::Left]},
                                                    {mInput.buttonAction[ControllerButtons::btnGrip], squeezeClickPath[VrController::Right]},
                                                    {mInput.analogAction[ControllerAnalog::analogGrip], squeezeClickPath[VrController::Left]},
                                                    {mInput.analogAction[ControllerAnalog::analogGrip], squeezeClickPath[VrController::Right]},
 
                                                    {mInput.analogAction[ControllerAnalog::analogTrigger], triggerValuePath[VrController::Left]},
                                                    {mInput.analogAction[ControllerAnalog::analogTrigger], triggerValuePath[VrController::Right]},
                                                    {mInput.buttonAction[ControllerButtons::btnTrigger], triggerClickPath[VrController::Left]},
                                                    {mInput.buttonAction[ControllerButtons::btnTrigger], triggerClickPath[VrController::Right]},
 
                                                    {mInput.buttonAction[ControllerButtons::btnMenu], menuClickPath[VrController::Left]},
                                                    {mInput.buttonAction[ControllerButtons::btnMenu], menuClickPath[VrController::Right]},
                                                    {mInput.poseAction, posePath[VrController::Left]},
                                                    {mInput.poseAction, posePath[VrController::Right]},
                                                    {mInput.vibrateAction, hapticPath[VrController::Left]},
                                                    {mInput.vibrateAction, hapticPath[VrController::Right]}} };
    XrInteractionProfileSuggestedBinding suggestedBindings{ XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING };
    suggestedBindings.interactionProfile = viveControllerInteractionProfilePath;
    suggestedBindings.suggestedBindings = bindings.data();
    suggestedBindings.countSuggestedBindings = (uint32_t)bindings.size();
    result = xrSuggestInteractionProfileBindings(mInstance, &suggestedBindings);
    if (result == XR_ERROR_PATH_UNSUPPORTED)
      MMechostr(MSKRUNTIME, "[OPENXR]: Runtime does not supports %s\n", "/interaction_profiles/htc/vive_controller");
    else
      xr_result(mInstance, result, "failed to suggest bindings");
  }
 
  // Suggest bindings for the Valve Index Controller.
  {
    XrPath indexControllerInteractionProfilePath;
    xrStringToPath(mInstance, "/interaction_profiles/valve/index_controller", &indexControllerInteractionProfilePath);
    std::vector<XrActionSuggestedBinding> bindings{ {
                                                    {mInput.buttonAction[ControllerButtons::btnRThumb], thumbClickPath[VrController::Right]},
                                                    {mInput.buttonAction[ControllerButtons::btnLThumb], thumbClickPath[VrController::Left]},
                                                    {mInput.touchAction[ControllerTouch::touchRThumb], thumbTouchPath[VrController::Right]},
                                                    {mInput.touchAction[ControllerTouch::touchLThumb], thumbTouchPath[VrController::Left]},
                                                    {mInput.analogAction[ControllerAnalog::analogPadX], thumbStickXPath[VrController::Left]},
                                                    {mInput.analogAction[ControllerAnalog::analogPadX], thumbStickXPath[VrController::Right]},
                                                    {mInput.analogAction[ControllerAnalog::analogPadY], thumbStickYPath[VrController::Left]},
                                                    {mInput.analogAction[ControllerAnalog::analogPadY], thumbStickYPath[VrController::Right]},
 
                                                    {mInput.analogAction[ControllerAnalog::analogGrip], squeezeValuePath[VrController::Left]},
                                                    {mInput.analogAction[ControllerAnalog::analogGrip], squeezeValuePath[VrController::Right]},
 
                                                    {mInput.analogAction[ControllerAnalog::analogTrigger], triggerValuePath[VrController::Left]},
                                                    {mInput.analogAction[ControllerAnalog::analogTrigger], triggerValuePath[VrController::Right]},
                                                    {mInput.touchAction[ControllerTouch::touchTrigger], triggerTouchPath[VrController::Left]},
                                                    {mInput.touchAction[ControllerTouch::touchTrigger], triggerTouchPath[VrController::Right]},
                                                    {mInput.buttonAction[ControllerButtons::btnTrigger], triggerClickPath[VrController::Left]},
                                                    {mInput.buttonAction[ControllerButtons::btnTrigger], triggerClickPath[VrController::Right]},
 
                                                    {mInput.buttonAction[ControllerButtons::btnMenu], sysClickPath[VrController::Left]},
                                                    {mInput.buttonAction[ControllerButtons::btnMenu], sysClickPath[VrController::Right]},
                                                    {mInput.poseAction, posePath[VrController::Left]},
                                                    {mInput.poseAction, posePath[VrController::Right]},
 
                                                    {mInput.vibrateAction, hapticPath[VrController::Left]},
                                                    {mInput.vibrateAction, hapticPath[VrController::Right]}} };
    XrInteractionProfileSuggestedBinding suggestedBindings{ XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING };
    suggestedBindings.interactionProfile = indexControllerInteractionProfilePath;
    suggestedBindings.suggestedBindings = bindings.data();
    suggestedBindings.countSuggestedBindings = (uint32_t)bindings.size();
    result = xrSuggestInteractionProfileBindings(mInstance, &suggestedBindings);
    if (result == XR_ERROR_PATH_UNSUPPORTED)
      MMechostr(MSKRUNTIME, "[OPENXR]: Runtime does not supports %s\n", "/interaction_profiles/valve/index_controller");
    else
      xr_result(mInstance, result, "failed to suggest bindings");
  }
 
  // Suggest bindings for the Microsoft Mixed Reality Motion Controller.
  {
    XrPath microsoftMixedRealityInteractionProfilePath;
    xrStringToPath(mInstance, "/interaction_profiles/microsoft/motion_controller", &microsoftMixedRealityInteractionProfilePath);
    std::vector<XrActionSuggestedBinding> bindings{ {
                                                    {mInput.buttonAction[ControllerButtons::btnRThumb], thumbClickPath[VrController::Right]},
                                                    {mInput.buttonAction[ControllerButtons::btnLThumb], thumbClickPath[VrController::Left]},
                                                    {mInput.touchAction[ControllerTouch::touchRThumb], trackpadTouchPath[VrController::Right]},
                                                    {mInput.touchAction[ControllerTouch::touchLThumb], trackpadTouchPath[VrController::Left]},
                                                    {mInput.analogAction[ControllerAnalog::analogPadX], thumbStickXPath[VrController::Left]},
                                                    {mInput.analogAction[ControllerAnalog::analogPadX], thumbStickXPath[VrController::Right]},
                                                    {mInput.analogAction[ControllerAnalog::analogPadY], thumbStickYPath[VrController::Left]},
                                                    {mInput.analogAction[ControllerAnalog::analogPadY], thumbStickYPath[VrController::Right]},
 
                                                    {mInput.buttonAction[ControllerButtons::btnGrip], squeezeClickPath[VrController::Left]},
                                                    {mInput.buttonAction[ControllerButtons::btnGrip], squeezeClickPath[VrController::Right]},
 
                                                    {mInput.analogAction[ControllerAnalog::analogTrigger], triggerValuePath[VrController::Left]},
                                                    {mInput.analogAction[ControllerAnalog::analogTrigger], triggerValuePath[VrController::Right]},
                                                    {mInput.buttonAction[ControllerButtons::btnTrigger], triggerValuePath[VrController::Left]},
                                                    {mInput.buttonAction[ControllerButtons::btnTrigger], triggerValuePath[VrController::Right]},
 
                                                    {mInput.buttonAction[ControllerButtons::btnMenu], menuClickPath[VrController::Left]},
                                                    {mInput.buttonAction[ControllerButtons::btnMenu], menuClickPath[VrController::Right]},
                                                    {mInput.poseAction, posePath[VrController::Left]},
                                                    {mInput.poseAction, posePath[VrController::Right]},
                                                    {mInput.vibrateAction, hapticPath[VrController::Left]},
                                                    {mInput.vibrateAction, hapticPath[VrController::Right]}} };
    XrInteractionProfileSuggestedBinding suggestedBindings{ XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING };
    suggestedBindings.interactionProfile = microsoftMixedRealityInteractionProfilePath;
    suggestedBindings.suggestedBindings = bindings.data();
    suggestedBindings.countSuggestedBindings = (uint32_t)bindings.size();
    result = xrSuggestInteractionProfileBindings(mInstance, &suggestedBindings);
    if (result == XR_ERROR_PATH_UNSUPPORTED)
      MMechostr(MSKRUNTIME, "[OPENXR]: Runtime does not supports %s\n", "/interaction_profiles/microsoft/motion_controller");
    else
      xr_result(mInstance, result, "failed to suggest bindings");
  }
 
  XrActionSpaceCreateInfo actionSpaceInfo{ XR_TYPE_ACTION_SPACE_CREATE_INFO };
  actionSpaceInfo.action = mInput.poseAction;
  actionSpaceInfo.poseInActionSpace.orientation.w = 1.f;
  actionSpaceInfo.subactionPath = mInput.handSubactionPath[VrController::Left];
  result = xrCreateActionSpace(mSession, &actionSpaceInfo, &mInput.handSpace[VrController::Left]);
  if (!xr_result(mInstance, result, "failed to create left hand pose space"))
    return false;
 
  actionSpaceInfo.subactionPath = mInput.handSubactionPath[VrController::Right];
  result = xrCreateActionSpace(mSession, &actionSpaceInfo, &mInput.handSpace[VrController::Right]);
  if (!xr_result(mInstance, result, "failed to create right hand pose space"))
    return false;
 
  XrSessionActionSetsAttachInfo attachInfo{ XR_TYPE_SESSION_ACTION_SETS_ATTACH_INFO, XR_NULL_HANDLE, 1, &mInput.actionSet };
  result = xrAttachSessionActionSets(mSession, &attachInfo);
  if (!xr_result(mInstance, result, "failed to attach action set"))
    return false;
 
  return true;
}
 
void sOpenXr::getControllerOffset(ControllerType type, VrController side, bool skeletal, Vector3 &vec, Quaternion &quat)
{
  // offsets to match Oculus hands model wrist
  switch (type)
  {
  case HANDS_CONTROLLER:
  case CLASSIC_CONTROLLER:
    if (skeletal)
      quat = quat * Quaternion(sqrt(0.5f), 0.0f, 0.0f, (side == VrController::Right) ? sqrt(0.5f) : -sqrt(0.5f));
    break;
  case HTCVIVE_CONTROLLER:
    if (skeletal)
    {
      quat = quat * Quaternion(sqrt(0.5f), 0.0f, 0.0f, (side == VrController::Right) ? sqrt(0.5f) : -sqrt(0.5f)); //90° on Z
      quat = quat * Quaternion(0.9990482f, 0.0436194f, 0.0f, 0.0f); // 5° on X
      quat = quat * Quaternion(0.9961947f, 0.0f, (side == VrController::Right) ? -0.0871557f : 0.0871557f, 0.0f); // 10° on Y
    }
    else
    {
      quat = quat * Quaternion(0.9063078f, -0.4226183f, 0.0f, 0.0f); // -50° on X
      vec += quat * Vector3((side == VrController::Right) ? 0.04f : -0.04f, -0.005f, 0.08f);
    }
    break;
  case VALVE_INDEX_CONTROLLER:
  case PICO_PICO4_CONTROLLER:
  case PICO_NEO3_CONTROLLER:
    if (skeletal)
    {
      quat = quat * Quaternion(sqrt(0.5f), 0.0f, 0.0f, (side == VrController::Right) ? sqrt(0.5f) : -sqrt(0.5f));
    }
    else
    {
      quat = quat * Quaternion(0.9961947f, -0.0871557f, 0.0f, 0.0f); // 10° on X
      vec += quat * Vector3((side == VrController::Right) ? 0.06f : -0.06f, -0.03f, 0.09f);
    }
    break;
  case OCULUS_TOUCH_CONTROLLER:
    if (skeletal)
    {
      quat = quat * Quaternion(sqrt(0.5f), 0.0f, 0.0f, (side == VrController::Right) ? sqrt(0.5f) : -sqrt(0.5f));
    }
    else
    {
      quat = quat * Quaternion(0.8660254f, -0.5f, 0.0f, 0.0f); // -60° on X
      vec += quat * Vector3((side == VrController::Right) ? 0.04f : -0.04f, 0.0f, 0.06f);
    }
    break;
  case MS_MOTION_CONTROLLER:
    if (skeletal)
      quat = quat * ((side == VrController::Right) ? Quaternion(0.0f, 0.0f, 0.0f, 1.0f) * Quaternion(sqrt(0.5f), 0.0f, 0.0f, -sqrt(0.5f)) : Quaternion(sqrt(0.5f), 0.0f, 0.0f, sqrt(0.5f)));
    break;
  default:
    break;
  }
}
 
void sOpenXr::updateControllers(XrFrameState frameState)
{
  XrResult result;
  XrHandJointLocationEXT joints[MAX_VR_CONTROLLERS][XR_HAND_JOINT_COUNT_EXT];
  XrHandJointVelocityEXT joint_velocity[MAX_VR_CONTROLLERS][XR_HAND_JOINT_COUNT_EXT];
  XrHandJointLocationsEXT joint_locations[MAX_VR_CONTROLLERS];
  XrHandJointVelocitiesEXT joint_velocities[MAX_VR_CONTROLLERS];
  XrHandTrackingAimStateFB aim_states[MAX_VR_CONTROLLERS];
 
  for (auto hand : { VrController::Left, VrController::Right })
  {
    mInput.handVisible[hand] = false;
    if (mHandTracking.system_supported)
    {
      //MMechostr(MSKDEBUG, "[OPENXR]: Hand tracking Update\n");
      if (mHandTracking.gestures)
        aim_states[hand] = XrHandTrackingAimStateFB{ XR_TYPE_HAND_TRACKING_AIM_STATE_FB, XR_NULL_HANDLE };
 
      joint_velocities[hand] = XrHandJointVelocitiesEXT{ XR_TYPE_HAND_JOINT_VELOCITIES_EXT, (mHandTracking.gestures) ? &aim_states[hand] : XR_NULL_HANDLE, XR_HAND_JOINT_COUNT_EXT, joint_velocity[hand] };
      joint_locations[hand] = XrHandJointLocationsEXT{ XR_TYPE_HAND_JOINT_LOCATIONS_EXT, &joint_velocities[hand], 0, XR_HAND_JOINT_COUNT_EXT, joints[hand] };
 
      if (mHandTracking.trackers[hand] == XR_NULL_HANDLE)
        continue;
 
      XrHandJointsLocateInfoEXT globalInfo = { XR_TYPE_HAND_JOINTS_LOCATE_INFO_EXT, XR_NULL_HANDLE, mPlaySpace, frameState.predictedDisplayTime };
      result = mHandTracking.pfnLocateHandJointsEXT(mHandTracking.trackers[hand], &globalInfo, &joint_locations[hand]);
      if (!xr_result(mInstance, result, "failed to locate hand %d joints!", hand))
        break;
 
      if (joint_locations[hand].isActive)
      {
        if ((joint_locations[hand].jointLocations[XR_HAND_JOINT_WRIST_EXT].locationFlags & XR_SPACE_LOCATION_POSITION_VALID_BIT) != 0 &&
            (joint_locations[hand].jointLocations[XR_HAND_JOINT_WRIST_EXT].locationFlags & XR_SPACE_LOCATION_ORIENTATION_VALID_BIT) != 0)
        {
          mControllerType[hand] = ControllerType::HANDS_CONTROLLER;
          mInput.handVisible[hand] = true;
 
          Vector3 offVec = Vector3(joint_locations[hand].jointLocations[XR_HAND_JOINT_WRIST_EXT].pose.position);
          Quaternion offQuat = Quaternion(joint_locations[hand].jointLocations[XR_HAND_JOINT_WRIST_EXT].pose.orientation);
          getControllerOffset(mLastControllerType, hand, true, offVec, offQuat);
 
          mInput.handQuat[hand] = offQuat;
          mInput.handPos[hand] = offVec;
 
          if ((joint_velocities[hand].jointVelocities[XR_HAND_JOINT_WRIST_EXT].velocityFlags & XR_SPACE_VELOCITY_LINEAR_VALID_BIT) != 0 &&
              (joint_velocities[hand].jointVelocities[XR_HAND_JOINT_WRIST_EXT].velocityFlags & XR_SPACE_VELOCITY_ANGULAR_VALID_BIT) != 0)
          {
            mInput.handVelocity[hand] = joint_velocities[hand].jointVelocities[XR_HAND_JOINT_WRIST_EXT].linearVelocity;
            mInput.handAngularVelocity[hand] = joint_velocities[hand].jointVelocities[XR_HAND_JOINT_WRIST_EXT].angularVelocity;
          }
          else
          {
            mInput.handVelocity[hand] = Vector3{ 0.0f, 0.0f, 0.0f };
            mInput.handAngularVelocity[hand] = Vector3{ 0.0f, 0.0f, 0.0f };
          }
 
          int thp = ((joint_locations[hand].jointLocations[XR_HAND_JOINT_THUMB_METACARPAL_EXT].locationFlags & XR_SPACE_LOCATION_POSITION_VALID_BIT) != 0) ? XR_HAND_JOINT_THUMB_METACARPAL_EXT : XR_HAND_JOINT_THUMB_PROXIMAL_EXT;
          int inp = ((joint_locations[hand].jointLocations[XR_HAND_JOINT_INDEX_METACARPAL_EXT].locationFlags & XR_SPACE_LOCATION_POSITION_VALID_BIT) != 0 && !mIsPico) ? XR_HAND_JOINT_INDEX_METACARPAL_EXT : XR_HAND_JOINT_INDEX_PROXIMAL_EXT;
          int mdp = ((joint_locations[hand].jointLocations[XR_HAND_JOINT_MIDDLE_METACARPAL_EXT].locationFlags & XR_SPACE_LOCATION_POSITION_VALID_BIT) != 0 && !mIsPico) ? XR_HAND_JOINT_MIDDLE_METACARPAL_EXT : XR_HAND_JOINT_MIDDLE_PROXIMAL_EXT;
          int rgp = ((joint_locations[hand].jointLocations[XR_HAND_JOINT_RING_METACARPAL_EXT].locationFlags & XR_SPACE_LOCATION_POSITION_VALID_BIT) != 0 && !mIsPico) ? XR_HAND_JOINT_RING_METACARPAL_EXT : XR_HAND_JOINT_RING_PROXIMAL_EXT;
          int ltp = ((joint_locations[hand].jointLocations[XR_HAND_JOINT_LITTLE_METACARPAL_EXT].locationFlags & XR_SPACE_LOCATION_POSITION_VALID_BIT) != 0) ? XR_HAND_JOINT_LITTLE_METACARPAL_EXT : XR_HAND_JOINT_LITTLE_PROXIMAL_EXT;
 
          for (uint32_t j = 0; j < joint_locations[hand].jointCount; j++)
          {
            if ((mIsPico && (j == XR_HAND_JOINT_INDEX_METACARPAL_EXT || j == XR_HAND_JOINT_MIDDLE_METACARPAL_EXT || j == XR_HAND_JOINT_RING_METACARPAL_EXT)) ||
                ((joint_locations[hand].jointLocations[j].locationFlags & XR_SPACE_LOCATION_ORIENTATION_VALID_BIT) == 0))
            {
              mHandTracking.bones[hand][j].valid = false;
            }
            else
            {
              if ((mLastControllerType == MS_MOTION_CONTROLLER) && j == XR_HAND_JOINT_WRIST_EXT && (hand == VrController::Left))
                mHandTracking.bones[hand][j].rotation = Quaternion(joint_locations[hand].jointLocations[j].pose.orientation) * Quaternion(0.0f, 0.0f, 0.0f, 1.0f);
              else
                mHandTracking.bones[hand][j].rotation = Quaternion(joint_locations[hand].jointLocations[j].pose.orientation);
 
              Quaternion qref(1.0, 0.0, 0.0, 0.0);
 
              if (j == thp ||
                  j == inp ||
                  j == mdp ||
                  j == rgp ||
                  j == ltp ||
                  j == 0)
                qref = Quaternion(joint_locations[hand].jointLocations[XR_HAND_JOINT_WRIST_EXT].pose.orientation);
              else
                qref = Quaternion(joint_locations[hand].jointLocations[j-1].pose.orientation);
 
              if (j > 1)
                mHandTracking.bones[hand][j].rotation = mHandTracking.bones[hand][j].rotation.Inverse() * qref;
 
              mHandTracking.bones[hand][j].position = joint_locations[hand].jointLocations[j].pose.position;
              mHandTracking.bones[hand][j].valid = true;
            }
          }
 
          bool mpinch = false;
          bool ipinch = false;
 
          // hand gesture based on distances
          Vector3 palmpos = mHandTracking.bones[hand][XR_HAND_JOINT_PALM_EXT].position;
          float thmubpdist = Vector3(mHandTracking.bones[hand][XR_HAND_JOINT_INDEX_TIP_EXT].position).distance(mHandTracking.bones[hand][XR_HAND_JOINT_THUMB_TIP_EXT].position);
          float thmubidist = Vector3(mHandTracking.bones[hand][XR_HAND_JOINT_INDEX_INTERMEDIATE_EXT].position).distance(mHandTracking.bones[hand][XR_HAND_JOINT_THUMB_TIP_EXT].position);
          float indexdist = palmpos.distance(mHandTracking.bones[hand][XR_HAND_JOINT_INDEX_TIP_EXT].position);
          float middist = palmpos.distance(mHandTracking.bones[hand][XR_HAND_JOINT_MIDDLE_TIP_EXT].position);
          float ringdist = palmpos.distance(mHandTracking.bones[hand][XR_HAND_JOINT_RING_TIP_EXT].position);
          float littledist = palmpos.distance(mHandTracking.bones[hand][XR_HAND_JOINT_LITTLE_TIP_EXT].position);
 
          if (mHandTracking.gestures)
          {
            mInput.buttonStates[hand][ControllerButtons::btnMenu] = ((aim_states[hand].status & XR_HAND_TRACKING_AIM_MENU_PRESSED_BIT_FB) != 0) ? true : false;
            mpinch = ((aim_states[hand].status & XR_HAND_TRACKING_AIM_MIDDLE_PINCHING_BIT_FB) != 0) ? true : false;
            ipinch = ((aim_states[hand].status & XR_HAND_TRACKING_AIM_INDEX_PINCHING_BIT_FB) != 0) ? true : false;
            mInput.analogStates[hand][ControllerAnalog::analogTrigger] = aim_states[hand].pinchStrengthIndex;
            mInput.analogStates[hand][ControllerAnalog::analogGrip] = aim_states[hand].pinchStrengthMiddle;
          }
          else
          {
            mInput.analogStates[hand][ControllerAnalog::analogTrigger] = (thmubpdist <= 0.035f) ? 1.0f - std::min(1.0f, std::max(0.0f, (1.0f / 3.5f) * ((thmubpdist - 0.01f) * 100.0f))) : 0.0f;
            ipinch = (mInput.analogStates[hand][ControllerAnalog::analogTrigger] >= 0.95) ? true : false;
            mpinch = ((middist <= 0.05f) && (ringdist <= 0.05f)) ? true : false;
            mInput.analogStates[hand][ControllerAnalog::analogGrip] = mpinch ? 1.0f : 0.0f;
          }
 
          if (!mInput.touchStates[hand][ControllerTouch::touchIndexPointing])
            mInput.touchStates[hand][ControllerTouch::touchIndexPointing] = ((middist <= 0.05f) && (ringdist <= 0.055f) && (littledist <= 0.065f) && (indexdist > 0.07f)) ? true : false;
          
          if (!mInput.buttonStates[hand][ControllerButtons::btnGrip])
            mInput.buttonStates[hand][ControllerButtons::btnGrip] = mpinch;
          
          if (!mInput.buttonStates[hand][ControllerButtons::btnTrigger])
            mInput.buttonStates[hand][ControllerButtons::btnTrigger] = ((indexdist <= 0.05f) || ipinch) ? true : false;
 
          if (hand == 0)
          {
            if (!mInput.buttonStates[hand][ControllerButtons::btnX])
              mInput.buttonStates[hand][ControllerButtons::btnX] = (thmubidist <= 0.030f) ? true : false;
          }
          else
          {
            if (!mInput.buttonStates[hand][ControllerButtons::btnA])
              mInput.buttonStates[hand][ControllerButtons::btnA] = (thmubidist <= 0.030f) ? true : false;
          }
        }
      }
    }
 
    if (mInput.handVisible[hand] == false)
    {
      XrSpaceVelocity spaceVelocity{XR_TYPE_SPACE_VELOCITY};
      XrSpaceLocation spaceLocation{XR_TYPE_SPACE_LOCATION, &spaceVelocity};
      result = xrLocateSpace(mInput.handSpace[hand], mPlaySpace, frameState.predictedDisplayTime, &spaceLocation);
      if (xr_result(mInstance, result, "Unable to locate %d hand action space in app space", hand))
      {
        if ((spaceLocation.locationFlags & XR_SPACE_LOCATION_POSITION_VALID_BIT) != 0 && (spaceLocation.locationFlags & XR_SPACE_LOCATION_ORIENTATION_VALID_BIT) != 0)
        {
          mInput.handVisible[hand] = true;
          mControllerType[hand] = ControllerType::CLASSIC_CONTROLLER;
 
          Vector3 offVec = Vector3(spaceLocation.pose.position);
          Quaternion offQuat = Quaternion(spaceLocation.pose.orientation);
          getControllerOffset(mLastControllerType, hand, false, offVec, offQuat);
 
          mInput.handQuat[hand] = offQuat;
          mInput.handPos[hand] = offVec;
        }
 
        if ((spaceVelocity.velocityFlags & XR_SPACE_VELOCITY_LINEAR_VALID_BIT) != 0 && (spaceVelocity.velocityFlags & XR_SPACE_VELOCITY_ANGULAR_VALID_BIT) != 0)
        {
          mInput.handVelocity[hand] = spaceVelocity.linearVelocity;
          mInput.handAngularVelocity[hand] = spaceVelocity.angularVelocity;
        }
        else
        {
          mInput.handVelocity[hand] = Vector3{0.0f, 0.0f, 0.0f};
          mInput.handAngularVelocity[hand] = Vector3{0.0f, 0.0f, 0.0f};
        }
      }
    }
  }
}
 
bool sOpenXr::Update()
{
  if (!mConnected || mPaused)
    return false;
 
  //poll events
  processEvents();
 
  if (mRequestRestart)
  {
    Disconnect();
    Connect();
  }
 
  for (unsigned int i = 0; i < MAX_VR_CONTROLLERS; i++)
    mInput.handVisible[i] = false;
 
  if (mConnected && mSessionRunning)
  {
    XrResult result;
 
    //poll actions
    processActions();
 
    XrFrameState frameState = { XR_TYPE_FRAME_STATE };
    XrFrameWaitInfo frameWaitInfo = { XR_TYPE_FRAME_WAIT_INFO };
    result = xrWaitFrame(mSession, &frameWaitInfo, &frameState);
    if (!xr_result(mInstance, result, "xrWaitFrame() was not successful, exiting..."))
      return false;
 
    updateControllers(frameState);
 
    uint32_t view_count = 0;
    XrViewLocateInfo view_locate_info = { XR_TYPE_VIEW_LOCATE_INFO, XR_NULL_HANDLE, mViewType, frameState.predictedDisplayTime, mPlaySpace };
    XrSpaceLocation view_in_stage = { XR_TYPE_SPACE_LOCATION, XR_NULL_HANDLE, 0, identity_pose };
    xrLocateSpace(mViewSpace, mPlaySpace, frameState.predictedDisplayTime, &view_in_stage);
 
    XrViewState view_state = { XR_TYPE_VIEW_STATE, XR_NULL_HANDLE };
    result = xrLocateViews(mSession, &view_locate_info, &view_state, (uint32_t)mViews.size(), &view_count, mViews.data());
    if (!xr_result(mInstance, result, "Could not locate views"))
      return false;
 
    for (uint32_t i = 0; i < view_count; i++)
    {
      mProjectionViews[i].pose = mViews[i].pose;
      mProjectionViews[i].fov = mViews[i].fov;
    }
 
    if (view_state.viewStateFlags & XR_VIEW_STATE_ORIENTATION_VALID_BIT)
      mPoseValid = true;
 
    if ((view_count > 1) && (view_state.viewStateFlags & XR_VIEW_STATE_POSITION_VALID_BIT))
      mLastIPD = Vector3(mViews[0].pose.position).distance(Vector3(mViews[1].pose.position));
 
    if (view_state.viewStateFlags & XR_VIEW_STATE_ORIENTATION_VALID_BIT)
    {
      mPreviousHmdQuat.w = view_in_stage.pose.orientation.w;
      mPreviousHmdQuat.x = view_in_stage.pose.orientation.x;
      mPreviousHmdQuat.y = view_in_stage.pose.orientation.y;
      mPreviousHmdQuat.z = view_in_stage.pose.orientation.z;
    }
 
    if (view_state.viewStateFlags & XR_VIEW_STATE_POSITION_VALID_BIT)
    {
      mPreviousHmdPos.x = view_in_stage.pose.position.x;
      mPreviousHmdPos.y = view_in_stage.pose.position.y;
      mPreviousHmdPos.z = view_in_stage.pose.position.z;
    }
 
    XrFrameBeginInfo frame_begin_info = { XR_TYPE_FRAME_BEGIN_INFO };
 
    result = xrBeginFrame(mSession, &frame_begin_info);
    if (!xr_result(mInstance, result, "failed to begin frame!"))
    {
      mSkipNextFrame = true;
      return false;
    }
    mSkipNextFrame = false;
 
    mPredictedDisplayTime = frameState.predictedDisplayTime;
  }
 
  return true;
}
 
void sOpenXr::UpdateTextures(SCOL_PTR_TYPE leftTexture, SCOL_PTR_TYPE rightTexture)
{
  if (mConnected && mSessionRunning && !mPaused && !mSkipNextFrame)
  {
    XrResult result;
    uint32_t view_count = (uint32_t)mViews.size();
    bool renderState = true;
    bool sessionActive = mState == XR_SESSION_STATE_READY || mState == XR_SESSION_STATE_VISIBLE || mState == XR_SESSION_STATE_FOCUSED;
    for (uint32_t i = 0; i < view_count; i++)
    {
      SCOL_PTR_TYPE eyetex = ((i == 0) ? leftTexture : rightTexture);
      if (!eyetex || !sessionActive)
      {
        renderState = false;
        break;
      }
 
      XrSwapchainImageAcquireInfo acquire_info = { XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO };
      uint32_t acquired_index = 0;
      result = xrAcquireSwapchainImage(mSwapchains[i], &acquire_info, &acquired_index);
      if (!xr_result(mInstance, result, "failed to acquire swapchain image!"))
      {
        renderState = false;
        //break;
      }
 
      XrSwapchainImageWaitInfo wait_info = { XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO, XR_NULL_HANDLE, XR_INFINITE_DURATION };
      result = xrWaitSwapchainImage(mSwapchains[i], &wait_info);
      if (!xr_result(mInstance, result, "failed to wait for swapchain image!"))
      {
        renderState = false;
        XrSwapchainImageReleaseInfo release_info = { XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO };
        result = xrReleaseSwapchainImage(mSwapchains[i], &release_info);
        xr_result(mInstance, result, "failed to release swapchain image!");
        break;
      }
 
      int32_t width = mProjectionViews[i].subImage.imageRect.extent.width;
      int32_t height = mProjectionViews[i].subImage.imageRect.extent.height;
 
      mRenderer->UpdateTextures(leftTexture, rightTexture, acquired_index, width, height, i);
      
      XrSwapchainImageReleaseInfo release_info = { XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO };
      result = xrReleaseSwapchainImage(mSwapchains[i], &release_info);
      if (!xr_result(mInstance, result, "failed to release swapchain image!"))
      {
        renderState = false;
        break;
      }
    }
 
    // projectionLayers struct reused for every frame
    std::vector<XrCompositionLayerBaseHeader*> layers;
    XrCompositionLayerFlags flags = XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT|XR_COMPOSITION_LAYER_CORRECT_CHROMATIC_ABERRATION_BIT;
    if (((mPassthroughFB.supported && mPassthroughFB.available) || mPassthroughHTC.supported) && mPassthroughEnable)
      flags |= XR_COMPOSITION_LAYER_UNPREMULTIPLIED_ALPHA_BIT/*|XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT*/;
 
    XrCompositionLayerProjection layer_proj = { XR_TYPE_COMPOSITION_LAYER_PROJECTION, XR_NULL_HANDLE,  flags,
                                                mPlaySpace, view_count, mProjectionViews.data() };
 
    if (sessionActive && renderState)
    {
      if (mPassthroughFB.supported && mPassthroughEnable && (mPassthroughFB.passthroughLayer != XR_NULL_HANDLE) && mPassthroughFB.available)
      {
        XrCompositionLayerPassthroughFB passthroughCompLayer = {XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB, XR_NULL_HANDLE,
                                                                XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT, XR_NULL_HANDLE,
                                                                mPassthroughFB.passthroughLayer};
 
        layers.push_back(reinterpret_cast<XrCompositionLayerBaseHeader*>(&passthroughCompLayer));
      }
      else if (mPassthroughHTC.supported && mPassthroughEnable)
      {
        XrPassthroughColorHTC passthroughColor = { XR_TYPE_PASSTHROUGH_COLOR_HTC, XR_NULL_HANDLE, 1.0f };
        XrCompositionLayerPassthroughHTC passthroughCompLayer = { XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_HTC, XR_NULL_HANDLE,
                                                                XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT, mViewSpace,
                                                                mPassthroughHTC.passthroughFeature, passthroughColor};
 
        layers.push_back(reinterpret_cast<XrCompositionLayerBaseHeader*>(&passthroughCompLayer));
      }
 
      layers.push_back(reinterpret_cast<XrCompositionLayerBaseHeader*>(&layer_proj));
    }
 
    XrFrameEndInfo frameEndInfo = {};
    frameEndInfo.type = XR_TYPE_FRAME_END_INFO;
    frameEndInfo.displayTime = mPredictedDisplayTime;
    frameEndInfo.layerCount = (uint32_t)layers.size();
    frameEndInfo.layers = layers.data();
    frameEndInfo.environmentBlendMode = mBlendMode;
    frameEndInfo.next = XR_NULL_HANDLE;
    result = xrEndFrame(mSession, &frameEndInfo);
    if (!xr_result(mInstance, result, "failed to end frame!") && mPassthroughFB.supported && mPassthroughEnable)
    {
      layers.clear();
      layers.push_back(reinterpret_cast<XrCompositionLayerBaseHeader*>(&layer_proj));
      frameEndInfo.layerCount = (uint32_t)layers.size();
      frameEndInfo.layers = layers.data();
      result = xrEndFrame(mSession, &frameEndInfo);
      xr_result(mInstance, result, "failed to end frame even with simple layer!");
    }
  }
}
 
bool sOpenXr::GetControllerVisibility(int id)
{
  return mInput.handVisible[id];
}
 
Vector3 sOpenXr::GetControllerPosition(int id)
{
  return mInput.handPos[id];
}
 
Quaternion sOpenXr::GetControllerOrientation(int id)
{
  return mInput.handQuat[id];
}
 
Vector3 sOpenXr::GetControllerVelocity(int id)
{
  return mInput.handVelocity[id];
}
 
Vector3 sOpenXr::GetControllerAngularVelocity(int id)
{
  return mInput.handAngularVelocity[id];
}
 
std::vector<bool> sOpenXr::GetControllerButtonsState(int id)
{
  if (!mConnected || id >= mInput.buttonStates.size())
  {
    std::vector<bool> ret;
    return ret;
  }
  return mInput.buttonStates[id];
}
 
std::vector<bool> sOpenXr::GetControllerTouchesState(int id)
{
  if (!mConnected || id >= mInput.touchStates.size())
  {
    std::vector<bool> ret;
    return ret;
  }
  return mInput.touchStates[id];
}
 
std::vector<float> sOpenXr::GetControllerAnalogState(int id)
{
  if (!mConnected || id >= mInput.analogStates.size())
  {
    std::vector<float> ret;
    return ret;
  }
  return mInput.analogStates[id];
}
 
void sOpenXr::SetControllerVibration(int id, float value)
{
  if (mState != XR_SESSION_STATE_FOCUSED)
    return;
 
  XrHapticVibration vibration{ XR_TYPE_HAPTIC_VIBRATION };
  vibration.amplitude = value;
  vibration.duration = XR_MIN_HAPTIC_DURATION;
  vibration.frequency = XR_FREQUENCY_UNSPECIFIED;
 
  XrHapticActionInfo hapticActionInfo{ XR_TYPE_HAPTIC_ACTION_INFO };
  hapticActionInfo.action = mInput.vibrateAction;
  hapticActionInfo.subactionPath = mInput.handSubactionPath[id];
  xrApplyHapticFeedback(mSession, &hapticActionInfo, (XrHapticBaseHeader*)&vibration);
}
 
std::array<Position, MAX_HAND_JOINTS> sOpenXr::GetControllerBones(int id, bool &ret)
{
  if (!mConnected || !mHandTracking.supported || (id > 1))
    ret = false;
  else
    ret = true;
  return mHandTracking.bones[id];
}
 
int sOpenXr::GetControllerType(int id)
{
  if (!mConnected)
    return 0;
 
  return mControllerType[id];
}
 
bool sOpenXr::IsPassthroughSupported()
{
  return mPassthroughFB.supported || mPassthroughHTC.supported;
}
 
bool sOpenXr::updatePassthrough()
{
  if (!IsPassthroughSupported())
    return false;
 
  XrResult result;
  if (mPassthroughEnable)
  {
    if (mPassthroughFB.supported)
    {
      result = mPassthroughFB.pfnXrPassthroughStartFBX(mPassthroughFB.passthroughFeature);
      if (!xr_result(mInstance, result, "Could not start passthrough!"))
        return false;
 
      result = mPassthroughFB.pfnXrPassthroughLayerResumeFBX(mPassthroughFB.passthroughLayer);
      if (!xr_result(mInstance, result, "Could not resume passthrough layer!"))
        return false;
 
      if (mPassthroughFB.pfnXrPassthroughLayerSetStyleFB)
      {
        XrPassthroughStyleFB style{ XR_TYPE_PASSTHROUGH_STYLE_FB };
        style.textureOpacityFactor = 1.0f;
        style.edgeColor = { 0.0f, 0.0f, 0.0f, 0.0f };
        mPassthroughFB.pfnXrPassthroughLayerSetStyleFB(mPassthroughFB.passthroughLayer, &style);
      }
 
      mPassthroughFB.available = true;
    }
    else if (mPassthroughHTC.supported)
    {
      XrPassthroughCreateInfoHTC passthroughInfo = { XR_TYPE_PASSTHROUGH_CREATE_INFO_HTC, XR_NULL_HANDLE, XR_PASSTHROUGH_FORM_PLANAR_HTC };
      result = mPassthroughHTC.pfnXrCreatePassthroughHTC(mSession, &passthroughInfo, &mPassthroughHTC.passthroughFeature);
      if (!xr_result(mInstance, result, "Could not start passthrough!"))
        return false;
    }
    SetSceneBlendMode(XR_ENVIRONMENT_BLEND_MODE_ALPHA_BLEND);
  }
  else
  {
    if (mPassthroughFB.supported)
    {
      result = mPassthroughFB.pfnXrPassthroughLayerPauseFBX(mPassthroughFB.passthroughLayer);
      if (!xr_result(mInstance, result, "Could not pause passthrough layer!"))
        return false;
 
      result = mPassthroughFB.pfnXrPassthroughPauseFBX(mPassthroughFB.passthroughFeature);
      if (!xr_result(mInstance, result, "Could not pause passthrough!"))
        return false;
    }
    else if (mPassthroughHTC.supported)
    {
      result = mPassthroughHTC.pfnXrDestroyPassthroughHTC(mPassthroughHTC.passthroughFeature);
      mPassthroughHTC.passthroughFeature = XR_NULL_HANDLE;
      if (!xr_result(mInstance, result, "Could not stop passthrough!"))
        return false;
    }
 
    SetSceneBlendMode(XR_ENVIRONMENT_BLEND_MODE_OPAQUE);
  }
  return true;
}
 
bool sOpenXr::SetPassthroughState(bool state)
{
  if (!IsPassthroughSupported() || (mPassthroughEnable == state))
    return false;
 
  mPassthroughEnable = state;
 
  updatePassthrough();
  return true;
}
 
bool sOpenXr::createPassthrough()
{
  if (!mPassthroughFB.supported)
    return false;
 
  XrResult result;
  /*
  XrSystemPassthroughProperties2FB passthrough_props{XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES2_FB};
  XrSystemProperties system_props = { XR_TYPE_SYSTEM_PROPERTIES, &passthrough_props};
 
  result = xrGetSystemProperties(mInstance, mSystemId, &system_props);
  if (!xr_result(mInstance, result, "Failed to get System properties"))
    return false;
 
  XrPassthroughFlagsFB flags = (passthrough_props.capabilities & XR_PASSTHROUGH_CAPABILITY_LAYER_DEPTH_BIT_FB) ? XR_PASSTHROUGH_LAYER_DEPTH_BIT_FB : 0;
   */
  XrPassthroughCreateInfoFB passthroughCreateInfo = {XR_TYPE_PASSTHROUGH_CREATE_INFO_FB, XR_NULL_HANDLE, 0};
  result = mPassthroughFB.pfnXrCreatePassthroughFBX(mSession, &passthroughCreateInfo, &mPassthroughFB.passthroughFeature);
  if (!xr_result(mInstance, result,"Failed to create a passthrough feature."))
    return mPassthroughFB.supported = false;
 
  // Create passthrough layer
  XrPassthroughLayerCreateInfoFB layerCreateInfo = {XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_FB, XR_NULL_HANDLE,
                                                    mPassthroughFB.passthroughFeature, 0,
                                                    XR_PASSTHROUGH_LAYER_PURPOSE_RECONSTRUCTION_FB};
  result = mPassthroughFB.pfnXrCreatePassthroughLayerFBX(mSession, &layerCreateInfo, &mPassthroughFB.passthroughLayer);
  if (!xr_result(mInstance, result, "Failed to create and start a passthrough layer"))
    return mPassthroughFB.supported = false;
 
  return true;
}
 
void sOpenXr::cleanPassthrough()
{
  XrResult result;
  if (mPassthroughFB.supported)
  {
    if (mPassthroughEnable)
    {
      result = mPassthroughFB.pfnXrPassthroughLayerPauseFBX(mPassthroughFB.passthroughLayer);
      xr_result(mInstance, result, "Could not pause passthrough layer!");
 
      result = mPassthroughFB.pfnXrPassthroughPauseFBX(mPassthroughFB.passthroughFeature);
      xr_result(mInstance, result, "Could not pause passthrough!");
    }
 
    // destroy passthrough layer
    if (mPassthroughFB.passthroughLayer != XR_NULL_HANDLE)
    {
      result = mPassthroughFB.pfnXrDestroyPassthroughLayerFBX(mPassthroughFB.passthroughLayer);
      xr_result(mInstance, result, "Failed to destroy a passthrough layer");
      mPassthroughFB.passthroughLayer = XR_NULL_HANDLE;
    }
 
    // destroy the feature
    if (mPassthroughFB.passthroughFeature != XR_NULL_HANDLE)
    {
      result = mPassthroughFB.pfnXrDestroyPassthroughFBX(mPassthroughFB.passthroughFeature);
      xr_result(mInstance, result, "Failed to destroy a passthrough feature.");
      mPassthroughFB.passthroughFeature = XR_NULL_HANDLE;
    }
  }
 
  if (mPassthroughHTC.supported && mPassthroughHTC.passthroughFeature != XR_NULL_HANDLE)
  {
    result = mPassthroughHTC.pfnXrDestroyPassthroughHTC(mPassthroughHTC.passthroughFeature);
    mPassthroughHTC.passthroughFeature = XR_NULL_HANDLE;
    xr_result(mInstance, result, "Failed to destroy a passthrough feature.");
  }
}