sOpenXR.h

/*
-----------------------------------------------------------------------------
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
 
-----------------------------------------------------------------------------
*/
 
#ifndef S_OPEN_XR_H
#define S_OPEN_XR_H
 
#include <scolPlugin.h>
 
#ifdef _WIN32
#include <unknwn.h>
 
#if defined(XR_USE_GRAPHICS_API_D3D11)
#  include <d3d11.h>
#endif
 
#endif // _WIN32
 
#include "vrmaths.h"
 
#include <vector>
#include <boost/thread.hpp>
#include <boost/bind/bind.hpp>
#include <string>
 
#include "platform.h"
#include "renderer.h"
#include "openxr/openxr.h"
#include "openxr/openxr_platform.h"
 
bool xr_result(XrInstance instance, XrResult result, const char* format, ...);
 
enum VrController
{
  Left = 0,
  Right = 1
};
 
enum VrEye
{
  LeftEye = 0,
  RightEye = 1,
  Undefined
};
 
static XrPosef identity_pose = { {0.0, 0.0, 0.0, 1.0}, {0.0, 0.0, 0.0} };
 
#define MAX_VR_CONTROLLERS 2
#define MAX_HAND_JOINTS XR_HAND_JOINT_LITTLE_TIP_EXT + 1
 
//TODO check SO3 config in usm.ini for renderer type
 
enum ExtensionType
{
  EXTENSION_NONE = 0,
  EXTENSION_HAND_TRACKING = 1,
  EXTENSION_PASSTHROUGH = 2
};
 
enum ControllerType
{
  CLASSIC_CONTROLLER = 0,
  HANDS_CONTROLLER = 1,
  HTCVIVE_CONTROLLER = 2,
  VALVE_INDEX_CONTROLLER = 3,
  OCULUS_TOUCH_CONTROLLER = 4,
  MS_MOTION_CONTROLLER = 5,
  PICO_NEO3_CONTROLLER = 6,
  PICO_PICO4_CONTROLLER = 7
};
 
enum ControllerButtons
{
  btnA = 0,
  btnB = 1,
  btnRThumb = 2,
  btnX = 3,
  btnY = 4,
  btnLThumb = 5,
  btnGrip = 6,
  btnTrigger = 7,
  btnMenu = 8,
  btnSize = 9
};
 
enum ControllerTouch
{
  touchA = 0,
  touchB = 1,
  touchRThumb = 2,
  touchX = 3,
  touchY = 4,
  touchLThumb = 5,
  touchThumbUp = 6,
  touchTrigger = 7,
  touchIndexPointing = 8,
  touchSize = 9
};
 
enum ControllerAnalog
{
  analogPadX = 0,
  analogPadY = 1,
  analogTrigger = 2,
  analogGrip = 3,
  analogSize = 4
};
 
struct Position {
  Vector3 position;
  Quaternion rotation;
  bool valid;
};
 
struct InputState {
  XrActionSet actionSet{ XR_NULL_HANDLE };
  std::vector<XrAction> buttonAction;
  std::vector<XrAction> touchAction;
  std::vector<XrAction> analogAction;
  std::vector<std::vector<bool> > buttonStates;
  std::vector<std::vector<bool> > touchStates;
  std::vector<std::vector<float> > analogStates;
 
  XrAction poseAction{ XR_NULL_HANDLE };
  XrAction vibrateAction{ XR_NULL_HANDLE };
 
  std::array<XrPath, MAX_VR_CONTROLLERS> handSubactionPath;
  std::array<XrSpace, MAX_VR_CONTROLLERS> handSpace;
  std::array<float, MAX_VR_CONTROLLERS> handScale = { {1.0f, 1.0f} };
  std::array<XrBool32, MAX_VR_CONTROLLERS> handActive;
  std::array<bool, MAX_VR_CONTROLLERS> handVisible;
  std::array<Vector3, MAX_VR_CONTROLLERS> handPos;
  std::array<Quaternion, MAX_VR_CONTROLLERS> handQuat;
  std::array<Vector3, MAX_VR_CONTROLLERS> handVelocity;
  std::array<Vector3, MAX_VR_CONTROLLERS> handAngularVelocity;
};
 
class sOpenXr
{
public:
protected:
  bool mConnected;
 
private:
  static sOpenXr* _singleton;
 
  std::string mAppName;
  std::shared_ptr<IPlatform> mPlatform;
  std::shared_ptr<IRenderer> mRenderer;
  RenderSystem mRendererType;
  XrInstance mInstance;
  XrSession mSession;
  XrSystemId mSystemId;
  XrSessionState mState;
  XrViewConfigurationType mViewType;
  XrSpace mPlaySpace;
  XrSpace mViewSpace;
  std::string mDeviceName;
  // Each physical Display/Eye is described by a view
  std::vector<XrView> mViews;
  std::vector<XrViewConfigurationView> mViewconfigViews;
  std::vector<XrCompositionLayerProjectionView> mProjectionViews;
  XrEnvironmentBlendMode mBlendMode;
  int mExtensionsEnable;
  
  // one swapchain per view. Using only one and rendering l/r to the same image is also possible.
  std::vector<XrSwapchain> mSwapchains;
  std::vector<Vector2i> mSwapchainsSize;
  InputState mInput;
 
  // hand tracking extension data
  struct
  {
    bool supported;
    bool gestures;
    // whether the current VR system in use has hand tracking
    bool system_supported;
    PFN_xrLocateHandJointsEXT pfnLocateHandJointsEXT;
    std::array<XrHandTrackerEXT, 2> trackers;
    std::array<std::array<Position, MAX_HAND_JOINTS>, 2> bones;
  } mHandTracking;
 
  struct
  {
      bool supported;
      bool available;
      XrPassthroughFB passthroughFeature;
      XrPassthroughLayerFB passthroughLayer;
      PFN_xrCreatePassthroughFB pfnXrCreatePassthroughFBX;
      PFN_xrDestroyPassthroughFB pfnXrDestroyPassthroughFBX;
      PFN_xrCreatePassthroughLayerFB pfnXrCreatePassthroughLayerFBX;
      PFN_xrPassthroughStartFB pfnXrPassthroughStartFBX;
      PFN_xrPassthroughPauseFB pfnXrPassthroughPauseFBX;
      PFN_xrPassthroughLayerPauseFB pfnXrPassthroughLayerResumeFBX;
      PFN_xrPassthroughLayerResumeFB pfnXrPassthroughLayerPauseFBX;
      PFN_xrDestroyPassthroughLayerFB pfnXrDestroyPassthroughLayerFBX;
      PFN_xrPassthroughLayerSetStyleFB pfnXrPassthroughLayerSetStyleFB;
  } mPassthroughFB;
 
  struct
  {
    bool supported;
    XrPassthroughHTC passthroughFeature;
    XrCompositionLayerPassthroughHTC passthroughLayer;
    PFN_xrCreatePassthroughHTC pfnXrCreatePassthroughHTC;
    PFN_xrDestroyPassthroughHTC pfnXrDestroyPassthroughHTC;
  } mPassthroughHTC;
 
  struct
  {
    bool supported;
  } mPicoController;
 
  ControllerType mLastControllerType;
  std::array<ControllerType, MAX_VR_CONTROLLERS> mControllerType;
  Quaternion mPreviousHmdQuat;
  Vector3 mPreviousHmdPos;
  std::array<float, 2> mFov;
  long long mFrameIndex;
  float mLastIPD;
  bool mPaused;
  XrTime mPredictedDisplayTime;
  float mScaleRatio;
  bool mSessionRunning;
  bool mRequestRestart;
  bool mPoseValid;
  bool mPassthroughEnable;
  bool mSkipNextFrame;
  bool mIsPico;
public:
  sOpenXr(RenderSystem rsys = XR_OPENGL_RENDERER, float scaleRatio = 1.0f);
 
  ~sOpenXr();
 
  static sOpenXr* CreateInstance(RenderSystem rsys = XR_OPENGL_RENDERER, float scale = 1.0f);
  static sOpenXr* GetInstance();
  static void Kill();
 
  XrInstance GetXrInstance();
  XrSession GetXrSession();
  bool Connect();
  void Disconnect();
  bool IsConnected();
  bool IsVisible();
  void SetScaleRatio(float ratio);
  bool GetHmdOrientation(Quaternion &quat);
  bool GetHmdPosition(Vector3 &vec);
  XrTime GetPredictedDisplayTime();
  void SetExtensions(int extensions);
  int GetExtensions();
  std::string GetHmdName();
  bool GetProjectionMatrix(VrEye eye, float nearclip, float farclip, Matrix4 &mat);
  bool GetStereoTextureSize(unsigned int &w, unsigned int &h);
  float GetStereoConfigFovY();
  float GetStereoConfigIPD();
  bool Update();
  void UpdateTextures(SCOL_PTR_TYPE leftTexture, SCOL_PTR_TYPE rightTexture);
  void SetState(bool state);
 
  bool GetControllerVisibility(int id);
  Vector3 GetControllerPosition(int id);
  Quaternion GetControllerOrientation(int id);
  Vector3 GetControllerVelocity(int id);
  Vector3 GetControllerAngularVelocity(int id);
  void SetControllerVibration(int id, float value);
 
  std::vector<bool> GetControllerButtonsState(int id);
  std::vector<bool> GetControllerTouchesState(int id);
  std::vector<float> GetControllerAnalogState(int id);
  std::array<Position, MAX_HAND_JOINTS> GetControllerBones(int id, bool &ret);
  int GetControllerType(int id);
  bool IsPassthroughSupported();
  bool SetPassthroughState(bool state);
  RenderSystem GetRenderer();
  void SetRenderer(RenderSystem renderer);
  void SetAppName(std::string name);
  bool SetSceneBlendMode(XrEnvironmentBlendMode mode);
protected:
  void printSupportedViewConfigs();
  void printViewconfigViewInfo();
  void printReferenceSpaces();
private:
  bool initialize();
  void cleanup();
  bool processEvents();
  void processActions();
  bool initControllers();
  void updateControllers(XrFrameState frameState);
  void getControllerOffset(ControllerType type, VrController side, bool skeletal, Vector3 &vec, Quaternion &quat);
  bool updatePassthrough();
  bool createPassthrough();
  void cleanPassthrough();
};
 
#endif