src/Aspect/Aspect_OpenVRSession.cxx

   1 // Copyright (c) 2020 OPEN CASCADE SAS
   2 //
   3 // This file is part of Open CASCADE Technology software library.
   4 //
   5 // This library is free software; you can redistribute it and/or modify it under
   6 // the terms of the GNU Lesser General Public License version 2.1 as published
   7 // by the Free Software Foundation, with special exception defined in the file
   8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
   9 // distribution for complete text of the license and disclaimer of any warranty.
  10 //
  11 // Alternatively, this file may be used under the terms of Open CASCADE
  12 // commercial license or contractual agreement.
  13
  14 #include <Aspect_OpenVRSession.hxx>
  15
  16 #include <Graphic3d_ArrayOfTriangles.hxx>
  17 #include <Image_PixMap.hxx>
  18 #include <Image_Texture.hxx>
  19 #include <Message.hxx>
  20 #include <Message_Messenger.hxx>
  21 #include <NCollection_LocalArray.hxx>
  22 #include <OSD.hxx>
  23 #include <OSD_Environment.hxx>
  24 #include <OSD_File.hxx>
  25 #include <OSD_Process.hxx>
  26
  27 #ifdef HAVE_OPENVR
  28   #include <openvr.h>
  29
  30 namespace
  31 {
  32   //! Print OpenVR compositor error.
  33   static const char* getVRCompositorError (vr::EVRCompositorError theVRError)
  34   {
  35     switch (theVRError)
  36     {
  37       case vr::VRCompositorError_None:                         return "None";
  38       case vr::VRCompositorError_RequestFailed:                return "Request Failed";
  39       case vr::VRCompositorError_IncompatibleVersion:          return "Incompatible Version";
  40       case vr::VRCompositorError_DoNotHaveFocus:               return "Do not have focus";
  41       case vr::VRCompositorError_InvalidTexture:               return "Invalid Texture";
  42       case vr::VRCompositorError_IsNotSceneApplication:        return "Is not scene application";
  43       case vr::VRCompositorError_TextureIsOnWrongDevice:       return "Texture is on wrong device";
  44       case vr::VRCompositorError_TextureUsesUnsupportedFormat: return "Texture uses unsupported format";
  45       case vr::VRCompositorError_SharedTexturesNotSupported:   return "Shared textures not supported";
  46       case vr::VRCompositorError_IndexOutOfRange:              return "Index out of range";
  47       case vr::VRCompositorError_AlreadySubmitted:             return "Already submitted";
  48       case vr::VRCompositorError_InvalidBounds:                return "Invalid Bounds";
  49       case vr::VRCompositorError_AlreadySet:                   return "Already set";
  50     }
  51     return "UNKNOWN";
  52   }
  53
  54   //! Print OpenVR input error.
  55   static const char* getVRInputError (vr::EVRInputError theVRError)
  56   {
  57     switch (theVRError)
  58     {
  59       case vr::VRInputError_None:                     return "None";
  60       case vr::VRInputError_NameNotFound:             return "NameNotFound";
  61       case vr::VRInputError_WrongType:                return "WrongType";
  62       case vr::VRInputError_InvalidHandle:            return "InvalidHandle";
  63       case vr::VRInputError_InvalidParam:             return "InvalidParam";
  64       case vr::VRInputError_NoSteam:                  return "NoSteam:";
  65       case vr::VRInputError_MaxCapacityReached:       return "MaxCapacityReached";
  66       case vr::VRInputError_IPCError:                 return "IPCError";
  67       case vr::VRInputError_NoActiveActionSet:        return "NoActiveActionSet";
  68       case vr::VRInputError_InvalidDevice:            return "InvalidDevice";
  69       case vr::VRInputError_InvalidSkeleton:          return "InvalidSkeleton";
  70       case vr::VRInputError_InvalidBoneCount:         return "InvalidBoneCount";
  71       case vr::VRInputError_InvalidCompressedData:    return "InvalidCompressedData";
  72       case vr::VRInputError_NoData:                   return "NoData";
  73       case vr::VRInputError_BufferTooSmall:           return "BufferTooSmall";
  74       case vr::VRInputError_MismatchedActionManifest: return "MismatchedActionManifest";
  75       case vr::VRInputError_MissingSkeletonData:      return "MissingSkeletonData";
  76       case vr::VRInputError_InvalidBoneIndex:         return "InvalidBoneIndex";
  77       case vr::VRInputError_InvalidPriority:          return "InvalidPriority";
  78       case vr::VRInputError_PermissionDenied:         return "PermissionDenied";
  79       case vr::VRInputError_InvalidRenderModel:       return "InvalidRenderModel";
  80     }
  81     return "UNKNOWN";
  82   }
  83
  84   //! Convert OpenVR mat4x4 into OCCT mat4x4.
  85   static NCollection_Mat4<double> mat44vr2Occ (const vr::HmdMatrix44_t& theMat4)
  86   {
  87     NCollection_Mat4<double> aMat4;
  88     for (int aRow = 0; aRow < 4; ++aRow)
  89     {
  90       aMat4.SetRow (aRow, NCollection_Vec4<double> (theMat4.m[aRow][0], theMat4.m[aRow][1], theMat4.m[aRow][2], theMat4.m[aRow][3]));
  91     }
  92     return aMat4;
  93   }
  94
  95   //! Convert OpenVR mat3x4 into OCCT gp_Trsf.
  96   static gp_Trsf mat34vr2OccTrsf (const vr::HmdMatrix34_t& theMat4)
  97   {
  98     gp_Trsf aTrsf;
  99     aTrsf.SetValues (theMat4.m[0][0], theMat4.m[0][1], theMat4.m[0][2], theMat4.m[0][3],
 100                      theMat4.m[1][0], theMat4.m[1][1], theMat4.m[1][2], theMat4.m[1][3],
 101                      theMat4.m[2][0], theMat4.m[2][1], theMat4.m[2][2], theMat4.m[2][3]);
 102     return aTrsf;
 103   }
 104
 105   //! Convert OpenVR tracked pose.
 106   static Aspect_TrackedDevicePose poseVr2Occ (const vr::TrackedDevicePose_t& theVrPose,
 107                                               const Standard_Real theUnitFactor)
 108   {
 109     Aspect_TrackedDevicePose aPose;
 110     aPose.Velocity.SetCoord (theVrPose.vVelocity.v[0], theVrPose.vVelocity.v[1], theVrPose.vVelocity.v[2]);
 111     aPose.AngularVelocity.SetCoord (theVrPose.vAngularVelocity.v[0], theVrPose.vAngularVelocity.v[1], theVrPose.vAngularVelocity.v[2]);
 112     aPose.IsValidPose = theVrPose.bPoseIsValid;
 113     aPose.IsConnectedDevice = theVrPose.bDeviceIsConnected;
 114     if (aPose.IsValidPose)
 115     {
 116       aPose.Orientation = mat34vr2OccTrsf (theVrPose.mDeviceToAbsoluteTracking);
 117       if (theUnitFactor != 1.0)
 118       {
 119         aPose.Orientation.SetTranslationPart (aPose.Orientation.TranslationPart() * theUnitFactor);
 120       }
 121     }
 122     return aPose;
 123   }
 124
 125   //! Find location of default actions manifest file (based on CSF_OCCTResourcePath or CASROOT variables).
 126   TCollection_AsciiString defaultActionsManifestInit()
 127   {
 128     const TCollection_AsciiString THE_ACTIONS_JSON = "occtvr_actions.json";
 129     const TCollection_AsciiString aResRoot (OSD_Environment ("CSF_OCCTResourcePath").Value());
 130     if (!aResRoot.IsEmpty())
 131     {
 132       if (OSD_File (aResRoot + "/" + THE_ACTIONS_JSON).Exists())
 133       {
 134         return aResRoot + "/" + THE_ACTIONS_JSON;
 135       }
 136       if (OSD_File (aResRoot + "/XRResources/" + THE_ACTIONS_JSON).Exists())
 137       {
 138         return aResRoot + "/XRResources/" + THE_ACTIONS_JSON;
 139       }
 140     }
 141     const TCollection_AsciiString aCasRoot (OSD_Environment ("CASROOT").Value());
 142     if (!aCasRoot.IsEmpty())
 143     {
 144       if (OSD_File (aCasRoot + "/" + THE_ACTIONS_JSON).Exists())
 145       {
 146         return aCasRoot + "/" + THE_ACTIONS_JSON;
 147       }
 148       if (OSD_File (aCasRoot + "/XRResources/" + THE_ACTIONS_JSON).Exists())
 149       {
 150         return aCasRoot + "/XRResources/" + THE_ACTIONS_JSON;
 151       }
 152       if (OSD_File (aCasRoot + "/XRResources/src/" + THE_ACTIONS_JSON).Exists())
 153       {
 154         return aCasRoot + "/XRResources/src/" + THE_ACTIONS_JSON;
 155       }
 156     }
 157     return OSD_Process::ExecutablePath() + "/occtvr_actions.json";
 158   }
 159 }
 160 #endif
 161
 162 IMPLEMENT_STANDARD_RTTIEXT(Aspect_OpenVRSession, Aspect_XRSession)
 163
 164 struct Aspect_OpenVRSession::VRContext
 165 {
 166 #ifdef HAVE_OPENVR
 167   vr::TrackedDevicePose_t TrackedPoses[vr::k_unMaxTrackedDeviceCount]; //!< array of tracked devices poses
 168   vr::IVRSystem*          System; //!< OpenVR session object
 169
 170   //! Empty constructor.
 171   Aspect_OpenVRSession::VRContext() : System (NULL)
 172   {
 173     memset (TrackedPoses, 0, sizeof(TrackedPoses));
 174   }
 175
 176   //! IVRSystem::PollNextEvent() wrapper.
 177   bool PollNextEvent (vr::VREvent_t& theEvent)
 178   {
 179     return System->PollNextEvent (&theEvent, sizeof(vr::VREvent_t));
 180   }
 181
 182   //! IVRSystem::GetControllerState() wrapper.
 183   bool GetControllerState (vr::VRControllerState_t& theState,
 184                            vr::TrackedDeviceIndex_t theDevice)
 185   {
 186     return System->GetControllerState (theDevice, &theState, sizeof(vr::VRControllerState_t&));
 187   }
 188
 189   //! Retrieve string property from OpenVR.
 190   TCollection_AsciiString getVrTrackedDeviceString (vr::TrackedDeviceIndex_t  theDevice,
 191                                                     vr::TrackedDeviceProperty theProperty,
 192                                                     vr::TrackedPropertyError* theError = NULL)
 193   {
 194     const uint32_t aBuffLen = System->GetStringTrackedDeviceProperty(theDevice, theProperty, NULL, 0, theError);
 195     if (aBuffLen == 0)
 196     {
 197       return TCollection_AsciiString();
 198     }
 199
 200     NCollection_LocalArray<char> aBuffer (aBuffLen + 1);
 201     System->GetStringTrackedDeviceProperty (theDevice, theProperty, aBuffer, aBuffLen, theError);
 202     aBuffer[aBuffLen] = '\0';
 203     const TCollection_AsciiString aResult (aBuffer);
 204     return aResult;
 205   }
 206 #endif
 207 };
 208
 209 #ifdef HAVE_OPENVR
 210 //! Image wrapping vr::RenderModel_TextureMap_t.
 211 class Aspect_OpenVRSession::VRImagePixmap : public Image_PixMap
 212 {
 213 public:
 214   //! Empty constructor.
 215   VRImagePixmap() : myVrTexture (NULL) {}
 216
 217   //! Load the texture.
 218   bool Load (vr::TextureID_t theTexture, const TCollection_AsciiString& theVrModelName)
 219   {
 220     vr::RenderModel_TextureMap_t* aVrTexture = NULL;
 221     vr::EVRRenderModelError aVrError = vr::VRRenderModelError_Loading;
 222     for (; aVrError == vr::VRRenderModelError_Loading;)
 223     {
 224       aVrError = vr::VRRenderModels()->LoadTexture_Async (theTexture, &aVrTexture);
 225       OSD::MilliSecSleep (1);
 226     }
 227     if (aVrError != vr::VRRenderModelError_None
 228      || aVrTexture == NULL)
 229     {
 230       Message::SendFail (TCollection_AsciiString ("OpenVR, Unable to load render model texture: ") + theVrModelName + " - " + int(aVrError));
 231       return false;
 232     }
 233
 234     InitWrapper (Image_Format_RGBA, (Standard_Byte* )aVrTexture->rubTextureMapData, aVrTexture->unWidth, aVrTexture->unHeight);
 235     myVrTexture = aVrTexture;
 236     return true;
 237   }
 238
 239   virtual ~VRImagePixmap()
 240   {
 241     if (myVrTexture != NULL)
 242     {
 243       vr::VRRenderModels()->FreeTexture (myVrTexture);
 244     }
 245   }
 246 private:
 247   vr::RenderModel_TextureMap_t* myVrTexture;
 248 };
 249
 250 //! Image_Texture extension using vr::VRRenderModels().
 251 class Aspect_OpenVRSession::VRTextureSource : public Image_Texture
 252 {
 253 public:
 254
 255   //! Main constructor.
 256   VRTextureSource (vr::TextureID_t theTextureId, const TCollection_AsciiString& theVrModelName)
 257   : Image_Texture (""), myVrTextureId (theTextureId), myVrModelName (theVrModelName)
 258   {
 259     myTextureId = TCollection_AsciiString ("texturevr://map_#") + (int )theTextureId;
 260   }
 261
 262 protected:
 263   //! Read image.
 264   virtual Handle(Image_PixMap) ReadImage() const Standard_OVERRIDE
 265   {
 266     Handle(VRImagePixmap) aPixmap = new VRImagePixmap();
 267     if (!aPixmap->Load (myVrTextureId, myVrModelName))
 268     {
 269       return Handle(VRImagePixmap)();
 270     }
 271     return aPixmap;
 272   }
 273 private:
 274   vr::TextureID_t         myVrTextureId;
 275   TCollection_AsciiString myVrModelName;
 276 };
 277 #endif
 278
 279 // =======================================================================
 280 // function : IsHmdPresent
 281 // purpose  :
 282 // =======================================================================
 283 bool Aspect_OpenVRSession::IsHmdPresent()
 284 {
 285 #ifdef HAVE_OPENVR
 286   return vr::VR_IsHmdPresent();
 287 #else
 288   return false;
 289 #endif
 290 }
 291
 292 // =======================================================================
 293 // function : defaultActionsManifest
 294 // purpose  :
 295 // =======================================================================
 296 TCollection_AsciiString Aspect_OpenVRSession::defaultActionsManifest()
 297 {
 298 #ifdef HAVE_OPENVR
 299   static const TCollection_AsciiString THE_ACTIONS_JSON_FULL = defaultActionsManifestInit();
 300   return THE_ACTIONS_JSON_FULL;
 301 #else
 302   return TCollection_AsciiString();
 303 #endif
 304 }
 305
 306 // =======================================================================
 307 // function : Aspect_OpenVRSession
 308 // purpose  :
 309 // =======================================================================
 310 Aspect_OpenVRSession::Aspect_OpenVRSession()
 311 : myContext (new VRContext())
 312 {
 313 #ifdef HAVE_OPENVR
 314   myActionsManifest = defaultActionsManifest();
 315   myTrackedPoses.Resize (0, (Standard_Integer )vr::k_unMaxTrackedDeviceCount - 1, false);
 316   {
 317     Handle(Aspect_XRActionSet) aHeadActionSet = new Aspect_XRActionSet ("/actions/generic_head");
 318     myActionSets.Add (aHeadActionSet->Id(), aHeadActionSet);
 319
 320     Handle(Aspect_XRAction) aHeadsetOn = new Aspect_XRAction (aHeadActionSet->Id() + "/in/headset_on_head", Aspect_XRActionType_InputDigital);
 321     aHeadActionSet->AddAction (aHeadsetOn);
 322     NCollection_Array1<Handle(Aspect_XRAction)>& aGenericSet = myRoleActions[Aspect_XRTrackedDeviceRole_Head];
 323     aGenericSet[Aspect_XRGenericAction_IsHeadsetOn] = aHeadsetOn;
 324   }
 325   for (int aHand = 0; aHand < 2; ++aHand)
 326   {
 327     NCollection_Array1<Handle(Aspect_XRAction)>& aGenericSet = myRoleActions[aHand == 0 ? Aspect_XRTrackedDeviceRole_LeftHand : Aspect_XRTrackedDeviceRole_RightHand];
 328     Handle(Aspect_XRActionSet) anActionSet = new Aspect_XRActionSet (aHand == 0 ? "/actions/generic_left" : "/actions/generic_right");
 329     myActionSets.Add (anActionSet->Id(), anActionSet);
 330
 331     Handle(Aspect_XRAction) anAppMenuClick = new Aspect_XRAction (anActionSet->Id() + "/in/appmenu_click", Aspect_XRActionType_InputDigital);
 332     anActionSet->AddAction (anAppMenuClick);
 333     aGenericSet[Aspect_XRGenericAction_InputAppMenu] = anAppMenuClick;
 334
 335     Handle(Aspect_XRAction) aSysMenuClick = new Aspect_XRAction (anActionSet->Id() + "/in/sysmenu_click", Aspect_XRActionType_InputDigital);
 336     anActionSet->AddAction (aSysMenuClick);
 337     aGenericSet[Aspect_XRGenericAction_InputSysMenu] = aSysMenuClick;
 338
 339     Handle(Aspect_XRAction) aTriggerPull = new Aspect_XRAction (anActionSet->Id() + "/in/trigger_pull", Aspect_XRActionType_InputAnalog);
 340     anActionSet->AddAction (aTriggerPull);
 341     aGenericSet[Aspect_XRGenericAction_InputTriggerPull] = aTriggerPull;
 342
 343     Handle(Aspect_XRAction) aTriggerClick = new Aspect_XRAction (anActionSet->Id() + "/in/trigger_click", Aspect_XRActionType_InputDigital);
 344     anActionSet->AddAction (aTriggerClick);
 345     aGenericSet[Aspect_XRGenericAction_InputTriggerClick] = aTriggerClick;
 346
 347     Handle(Aspect_XRAction) aGripClick = new Aspect_XRAction (anActionSet->Id() + "/in/grip_click", Aspect_XRActionType_InputDigital);
 348     anActionSet->AddAction (aGripClick);
 349     aGenericSet[Aspect_XRGenericAction_InputGripClick] = aGripClick;
 350
 351     Handle(Aspect_XRAction) aPadPos = new Aspect_XRAction (anActionSet->Id() + "/in/trackpad_position", Aspect_XRActionType_InputAnalog);
 352     anActionSet->AddAction (aPadPos);
 353     aGenericSet[Aspect_XRGenericAction_InputTrackPadPosition] = aPadPos;
 354
 355     Handle(Aspect_XRAction) aPadTouch = new Aspect_XRAction (anActionSet->Id() + "/in/trackpad_touch", Aspect_XRActionType_InputDigital);
 356     anActionSet->AddAction (aPadTouch);
 357     aGenericSet[Aspect_XRGenericAction_InputTrackPadTouch] = aPadTouch;
 358
 359     Handle(Aspect_XRAction) aPadClick = new Aspect_XRAction (anActionSet->Id() + "/in/trackpad_click", Aspect_XRActionType_InputDigital);
 360     anActionSet->AddAction (aPadClick);
 361     aGenericSet[Aspect_XRGenericAction_InputTrackPadClick] = aPadClick;
 362
 363     Handle(Aspect_XRAction) aPoseBase = new Aspect_XRAction (anActionSet->Id() + "/in/pose_base", Aspect_XRActionType_InputPose);
 364     anActionSet->AddAction (aPoseBase);
 365     aGenericSet[Aspect_XRGenericAction_InputPoseBase] = aPoseBase;
 366
 367     Handle(Aspect_XRAction) aPoseFront = new Aspect_XRAction (anActionSet->Id() + "/in/pose_front", Aspect_XRActionType_InputPose);
 368     anActionSet->AddAction (aPoseFront);
 369     aGenericSet[Aspect_XRGenericAction_InputPoseFront] = aPoseFront;
 370
 371     Handle(Aspect_XRAction) aPoseGrip = new Aspect_XRAction (anActionSet->Id() + "/in/pose_handgrip", Aspect_XRActionType_InputPose);
 372     anActionSet->AddAction (aPoseGrip);
 373     aGenericSet[Aspect_XRGenericAction_InputPoseHandGrip] = aPoseGrip;
 374
 375     Handle(Aspect_XRAction) aPoseTip = new Aspect_XRAction (anActionSet->Id() + "/in/pose_tip", Aspect_XRActionType_InputPose);
 376     anActionSet->AddAction (aPoseTip);
 377     aGenericSet[Aspect_XRGenericAction_InputPoseFingerTip] = aPoseTip;
 378
 379     Handle(Aspect_XRAction) aHaptic = new Aspect_XRAction (anActionSet->Id() + "/out/haptic", Aspect_XRActionType_OutputHaptic);
 380     anActionSet->AddAction (aHaptic);
 381     aGenericSet[Aspect_XRGenericAction_OutputHaptic] = aHaptic;
 382
 383     Handle(Aspect_XRAction) aThumbsctickPos = new Aspect_XRAction (anActionSet->Id() + "/in/thumbstick_position", Aspect_XRActionType_InputAnalog);
 384     anActionSet->AddAction (aThumbsctickPos);
 385     aGenericSet[Aspect_XRGenericAction_InputThumbstickPosition] = aThumbsctickPos;
 386
 387     Handle(Aspect_XRAction) aThumbsctickTouch = new Aspect_XRAction (anActionSet->Id() + "/in/thumbstick_touch", Aspect_XRActionType_InputDigital);
 388     anActionSet->AddAction (aThumbsctickTouch);
 389     aGenericSet[Aspect_XRGenericAction_InputThumbstickTouch] = aThumbsctickTouch;
 390
 391     Handle(Aspect_XRAction) aThumbsctickClick = new Aspect_XRAction (anActionSet->Id() + "/in/thumbstick_click", Aspect_XRActionType_InputDigital);
 392     anActionSet->AddAction (aThumbsctickClick);
 393     aGenericSet[Aspect_XRGenericAction_InputThumbstickClick] = aThumbsctickClick;
 394   }
 395 #endif
 396 }
 397
 398 // =======================================================================
 399 // function : ~Aspect_OpenVRSession
 400 // purpose  :
 401 // =======================================================================
 402 Aspect_OpenVRSession::~Aspect_OpenVRSession()
 403 {
 404   closeVR();
 405   delete myContext;
 406 }
 407
 408 // =======================================================================
 409 // function : closeVR
 410 // purpose  :
 411 // =======================================================================
 412 void Aspect_OpenVRSession::closeVR()
 413 {
 414 #ifdef HAVE_OPENVR
 415   if (myContext->System != NULL)
 416   {
 417     vr::VR_Shutdown();
 418     myContext->System = NULL;
 419   }
 420 #endif
 421 }
 422
 423 // =======================================================================
 424 // function : getVRSystem
 425 // purpose  :
 426 // =======================================================================
 427 void* Aspect_OpenVRSession::getVRSystem() const
 428 {
 429 #ifdef HAVE_OPENVR
 430   return myContext->System;
 431 #else
 432   return NULL;
 433 #endif
 434 }
 435
 436 // =======================================================================
 437 // function : Close
 438 // purpose  :
 439 // =======================================================================
 440 void Aspect_OpenVRSession::Close()
 441 {
 442   closeVR();
 443 }
 444
 445 // =======================================================================
 446 // function : IsOpen
 447 // purpose  :
 448 // =======================================================================
 449 bool Aspect_OpenVRSession::IsOpen() const
 450 {
 451 #ifdef HAVE_OPENVR
 452   return myContext->System != NULL;
 453 #else
 454   return false;
 455 #endif
 456 }
 457
 458 // =======================================================================
 459 // function : Open
 460 // purpose  :
 461 // =======================================================================
 462 bool Aspect_OpenVRSession::Open()
 463 {
 464 #ifdef HAVE_OPENVR
 465   if (myContext->System != NULL)
 466   {
 467     return true;
 468   }
 469
 470   vr::EVRInitError aVrError = vr::VRInitError_None;
 471   myContext->System = vr::VR_Init (&aVrError, vr::VRApplication_Scene);
 472   if (aVrError != vr::VRInitError_None)
 473   {
 474     myContext->System = NULL;
 475     Message::SendFail (TCollection_AsciiString ("OpenVR, Unable to init VR runtime: ") + vr::VR_GetVRInitErrorAsEnglishDescription (aVrError));
 476     Close();
 477     return false;
 478   }
 479
 480   /*vr::IVRRenderModels* aRenderModels = (vr::IVRRenderModels* )vr::VR_GetGenericInterface (vr::IVRRenderModels_Version, &aVrError);
 481   if (aRenderModels == NULL)
 482   {
 483     Message::SendFail (TCollection_AsciiString ("Unable to get render model interface: ") + vr::VR_GetVRInitErrorAsEnglishDescription (aVrError));;
 484   }*/
 485
 486   NCollection_Vec2<uint32_t> aRenderSize;
 487   myContext->System->GetRecommendedRenderTargetSize (&aRenderSize.x(), &aRenderSize.y());
 488   myRendSize = NCollection_Vec2<int> (aRenderSize);
 489   myDispFreq = myContext->System->GetFloatTrackedDeviceProperty (vr::k_unTrackedDeviceIndex_Hmd, vr::Prop_DisplayFrequency_Float);
 490   if (myRendSize.x() <= 0
 491    || myRendSize.y() <= 0)
 492   {
 493     Close();
 494     return false;
 495   }
 496   updateProjectionFrustums();
 497   initInput();
 498   return true;
 499 #else
 500   Message::SendFail ("Open CASCADE has been built without OpenVR support");
 501   return false;
 502 #endif
 503 }
 504
 505 // =======================================================================
 506 // function : initInput
 507 // purpose  :
 508 // =======================================================================
 509 bool Aspect_OpenVRSession::initInput()
 510 {
 511 #ifdef HAVE_OPENVR
 512   if (myContext->System == NULL)
 513   {
 514     return false;
 515   }
 516
 517   if (!OSD_File (myActionsManifest).Exists())
 518   {
 519     Message::SendFail (TCollection_AsciiString ("OpenVR, Unable to open actions manifest '") + myActionsManifest  + "'");
 520     return false;
 521   }
 522
 523   vr::EVRInputError aVrError = vr::VRInput()->SetActionManifestPath (myActionsManifest.ToCString());
 524   if (aVrError != vr::VRInputError_None)
 525   {
 526     Message::SendFail (TCollection_AsciiString ("OpenVR, Unable to load actions manifest '") + myActionsManifest
 527                      + "': " + getVRInputError (aVrError));
 528     return false;
 529   }
 530
 531   bool hasErrors = false;
 532   for (Aspect_XRActionSetMap::Iterator aSetIter (myActionSets); aSetIter.More(); aSetIter.Next())
 533   {
 534     const Handle(Aspect_XRActionSet)& anActionSet = aSetIter.Value();
 535     for (Aspect_XRActionMap::Iterator anActionIter (anActionSet->Actions()); anActionIter.More(); anActionIter.Next())
 536     {
 537       const Handle(Aspect_XRAction)& anAction = anActionIter.Value();
 538       vr::VRActionHandle_t anActionHandle = 0;
 539       aVrError = vr::VRInput()->GetActionHandle (anAction->Id().ToCString(), &anActionHandle);
 540       if (aVrError == vr::VRInputError_None)
 541       {
 542         anAction->SetRawHandle (anActionHandle);
 543       }
 544       else
 545       {
 546         hasErrors = true;
 547         Message::SendFail (TCollection_AsciiString ("OpenVR, Unable to load action '") + anAction->Id() + "' from '" + myActionsManifest
 548                          + "': " + getVRInputError (aVrError));
 549       }
 550     }
 551
 552     vr::VRActionSetHandle_t anActionSetHandle = 0;
 553     aVrError = vr::VRInput()->GetActionSetHandle (anActionSet->Id().ToCString(), &anActionSetHandle);
 554     if (aVrError == vr::VRInputError_None)
 555     {
 556       anActionSet->SetRawHandle (anActionSetHandle);
 557     }
 558     else
 559     {
 560       hasErrors = true;
 561       Message::SendFail (TCollection_AsciiString ("OpenVR, Unable to load action set '") + anActionSet->Id() + "' from '" + myActionsManifest
 562                        + "': " + getVRInputError (aVrError));
 563     }
 564   }
 565   return !hasErrors;
 566 #else
 567   return false;
 568 #endif
 569 }
 570
 571 // =======================================================================
 572 // function : GetString
 573 // purpose  :
 574 // =======================================================================
 575 TCollection_AsciiString Aspect_OpenVRSession::GetString (InfoString theInfo) const
 576 {
 577 #ifdef HAVE_OPENVR
 578   if (myContext->System != NULL)
 579   {
 580     vr::ETrackedDeviceProperty aVrProp = vr::Prop_Invalid;
 581     switch (theInfo)
 582     {
 583       case InfoString_Vendor:       aVrProp = vr::Prop_ManufacturerName_String; break;
 584       case InfoString_Device:       aVrProp = vr::Prop_ModelNumber_String; break;
 585       case InfoString_Tracker:      aVrProp = vr::Prop_TrackingSystemName_String; break;
 586       case InfoString_SerialNumber: aVrProp = vr::Prop_SerialNumber_String; break;
 587     }
 588     if (aVrProp != vr::Prop_Invalid)
 589     {
 590       return myContext->getVrTrackedDeviceString (vr::k_unTrackedDeviceIndex_Hmd, aVrProp);
 591     }
 592   }
 593 #else
 594   (void )theInfo;
 595 #endif
 596   return TCollection_AsciiString();
 597 }
 598
 599 // =======================================================================
 600 // function : NamedTrackedDevice
 601 // purpose  :
 602 // =======================================================================
 603 Standard_Integer Aspect_OpenVRSession::NamedTrackedDevice (Aspect_XRTrackedDeviceRole theDevice) const
 604 {
 605 #ifdef HAVE_OPENVR
 606   if (myContext->System != NULL)
 607   {
 608     vr::TrackedDeviceIndex_t aDevIndex = vr::k_unTrackedDeviceIndexInvalid;
 609     switch (theDevice)
 610     {
 611       case Aspect_XRTrackedDeviceRole_Head:      aDevIndex = vr::k_unTrackedDeviceIndex_Hmd; break;
 612       case Aspect_XRTrackedDeviceRole_LeftHand:  aDevIndex = myContext->System->GetTrackedDeviceIndexForControllerRole (vr::TrackedControllerRole_LeftHand);  break;
 613       case Aspect_XRTrackedDeviceRole_RightHand: aDevIndex = myContext->System->GetTrackedDeviceIndexForControllerRole (vr::TrackedControllerRole_RightHand); break;
 614       case Aspect_XRTrackedDeviceRole_Other: break;
 615     }
 616     if (aDevIndex == vr::k_unTrackedDeviceIndexInvalid)
 617     {
 618       return -1;
 619     }
 620     return (Standard_Integer )aDevIndex;
 621   }
 622 #else
 623   (void )theDevice;
 624 #endif
 625   return -1;
 626 }
 627
 628 // =======================================================================
 629 // function : loadRenderModel
 630 // purpose  :
 631 // =======================================================================
 632 Handle(Graphic3d_ArrayOfTriangles) Aspect_OpenVRSession::loadRenderModel (Standard_Integer theDevice,
 633                                                                           Standard_Boolean theToApplyUnitFactor,
 634                                                                           Handle(Image_Texture)& theTexture)
 635 {
 636   if (theDevice < 0)
 637   {
 638     return Handle(Graphic3d_ArrayOfTriangles)();
 639   }
 640 #ifdef HAVE_OPENVR
 641   if (myContext->System == NULL)
 642   {
 643     return Handle(Graphic3d_ArrayOfTriangles)();
 644   }
 645
 646   const TCollection_AsciiString aRenderModelName = myContext->getVrTrackedDeviceString (theDevice, vr::Prop_RenderModelName_String);
 647   if (aRenderModelName.IsEmpty())
 648   {
 649     return Handle(Graphic3d_ArrayOfTriangles)();
 650   }
 651
 652   vr::RenderModel_t* aVrModel = NULL;
 653   vr::EVRRenderModelError aVrError = vr::VRRenderModelError_Loading;
 654   for (; aVrError == vr::VRRenderModelError_Loading;)
 655   {
 656     aVrError = vr::VRRenderModels()->LoadRenderModel_Async (aRenderModelName.ToCString(), &aVrModel);
 657     OSD::MilliSecSleep (1);
 658   }
 659   if (aVrError != vr::VRRenderModelError_None)
 660   {
 661     Message::SendFail (TCollection_AsciiString ("OpenVR, Unable to load render model: ") + aRenderModelName + " - " + int(aVrError));
 662     return Handle(Graphic3d_ArrayOfTriangles)();
 663   }
 664
 665   if (aVrModel->diffuseTextureId >= 0)
 666   {
 667     theTexture = new VRTextureSource (aVrModel->diffuseTextureId, aRenderModelName);
 668   }
 669
 670   const float aScale = theToApplyUnitFactor ? float(myUnitFactor) : 1.0f;
 671   Handle(Graphic3d_ArrayOfTriangles) aTris = new Graphic3d_ArrayOfTriangles ((int )aVrModel->unVertexCount, (int )aVrModel->unTriangleCount * 3,
 672                                                                              Graphic3d_ArrayFlags_VertexNormal | Graphic3d_ArrayFlags_VertexTexel);
 673   for (uint32_t aVertIter = 0; aVertIter < aVrModel->unVertexCount; ++aVertIter)
 674   {
 675     const vr::RenderModel_Vertex_t& aVert = aVrModel->rVertexData[aVertIter];
 676     aTris->AddVertex (aVert.vPosition.v[0] * aScale, aVert.vPosition.v[1] * aScale, aVert.vPosition.v[2] * aScale,
 677                       aVert.vNormal.v[0], aVert.vNormal.v[1], aVert.vNormal.v[2],
 678                       aVert.rfTextureCoord[0], aVert.rfTextureCoord[1]);
 679   }
 680   for (uint32_t aTriIter = 0; aTriIter < aVrModel->unTriangleCount; ++aTriIter)
 681   {
 682     aTris->AddEdges (aVrModel->rIndexData[aTriIter * 3 + 0] + 1,
 683                      aVrModel->rIndexData[aTriIter * 3 + 1] + 1,
 684                      aVrModel->rIndexData[aTriIter * 3 + 2] + 1);
 685   }
 686
 687   vr::VRRenderModels()->FreeRenderModel (aVrModel);
 688   return aTris;
 689 #else
 690   (void )theToApplyUnitFactor;
 691   (void )theTexture;
 692   return Handle(Graphic3d_ArrayOfTriangles)();
 693 #endif
 694 }
 695
 696 // =======================================================================
 697 // function : EyeToHeadTransform
 698 // purpose  :
 699 // =======================================================================
 700 NCollection_Mat4<double> Aspect_OpenVRSession::EyeToHeadTransform (Aspect_Eye theEye) const
 701 {
 702 #ifdef HAVE_OPENVR
 703   if (myContext->System != NULL)
 704   {
 705     const vr::HmdMatrix34_t aMatVr = myContext->System->GetEyeToHeadTransform (theEye == Aspect_Eye_Right ? vr::Eye_Right : vr::Eye_Left);
 706     gp_Trsf aTrsf = mat34vr2OccTrsf (aMatVr);
 707     if (myUnitFactor != 1.0)
 708     {
 709       aTrsf.SetTranslationPart (aTrsf.TranslationPart() * myUnitFactor);
 710     }
 711     NCollection_Mat4<double> aMat4;
 712     aTrsf.GetMat4 (aMat4);
 713     return aMat4;
 714   }
 715 #else
 716   (void )theEye;
 717 #endif
 718   return NCollection_Mat4<double>();
 719 }
 720
 721 // =======================================================================
 722 // function : ProjectionMatrix
 723 // purpose  :
 724 // =======================================================================
 725 NCollection_Mat4<double> Aspect_OpenVRSession::ProjectionMatrix (Aspect_Eye theEye,
 726                                                                  double theZNear,
 727                                                                  double theZFar) const
 728 {
 729 #ifdef HAVE_OPENVR
 730   if (myContext->System != NULL)
 731   {
 732     const vr::HmdMatrix44_t aMat4 = myContext->System->GetProjectionMatrix (theEye == Aspect_Eye_Right ? vr::Eye_Right : vr::Eye_Left,
 733                                                                             (float )theZNear, (float )theZFar);
 734     return mat44vr2Occ (aMat4);
 735   }
 736 #else
 737   (void )theEye;
 738   (void )theZNear;
 739   (void )theZFar;
 740 #endif
 741   return NCollection_Mat4<double>();
 742 }
 743
 744 // =======================================================================
 745 // function : updateProjectionFrustums
 746 // purpose  :
 747 // =======================================================================
 748 void Aspect_OpenVRSession::updateProjectionFrustums()
 749 {
 750 #ifdef HAVE_OPENVR
 751   Aspect_FrustumLRBT<float> aFrustL, aFrustR;
 752   myContext->System->GetProjectionRaw (vr::Eye_Left,  &aFrustL.Left, &aFrustL.Right, &aFrustL.Top, &aFrustL.Bottom);
 753   myContext->System->GetProjectionRaw (vr::Eye_Right, &aFrustR.Left, &aFrustR.Right, &aFrustR.Top, &aFrustR.Bottom);
 754   myFrustumL = Aspect_FrustumLRBT<double> (aFrustL);
 755   myFrustumR = Aspect_FrustumLRBT<double> (aFrustR);
 756   std::swap (myFrustumL.Top, myFrustumL.Bottom);
 757   std::swap (myFrustumR.Top, myFrustumR.Bottom);
 758
 759   const NCollection_Vec2<double> aTanHalfFov (NCollection_Vec4<float>(-aFrustL.Left, aFrustL.Right,  -aFrustR.Left, aFrustR.Right).maxComp(),
 760                                               NCollection_Vec4<float>(-aFrustL.Top,  aFrustL.Bottom, -aFrustR.Top,  aFrustR.Bottom).maxComp());
 761   myAspect = aTanHalfFov.x() / aTanHalfFov.y();
 762   myFieldOfView = 2.0 * ATan(aTanHalfFov.y()) * 180.0 / M_PI;
 763
 764   // Intra-ocular Distance can be changed in runtime
 765   //const vr::HmdMatrix34_t aLeftToHead  = myContext->System->GetEyeToHeadTransform (vr::Eye_Left);
 766   //const vr::HmdMatrix34_t aRightToHead = myContext->System->GetEyeToHeadTransform (vr::Eye_Right);
 767   //myIod = aRightToHead.m[0][3] - aLeftToHead.m[0][3];
 768   myIod = myContext->System->GetFloatTrackedDeviceProperty (vr::k_unTrackedDeviceIndex_Hmd, vr::Prop_UserIpdMeters_Float);
 769   myIod *= myUnitFactor;
 770 #endif
 771 }
 772
 773 // =======================================================================
 774 // function : SetTrackingOrigin
 775 // purpose  :
 776 // =======================================================================
 777 void Aspect_OpenVRSession::SetTrackingOrigin (TrackingUniverseOrigin theOrigin)
 778 {
 779 #ifdef HAVE_OPENVR
 780   if (myContext->System != NULL)
 781   {
 782     vr::ETrackingUniverseOrigin anOrigin = vr::TrackingUniverseStanding;
 783     switch (theOrigin)
 784     {
 785       case TrackingUniverseOrigin_Seated:   anOrigin = vr::TrackingUniverseSeated;   break;
 786       case TrackingUniverseOrigin_Standing: anOrigin = vr::TrackingUniverseStanding; break;
 787     }
 788     vr::VRCompositor()->SetTrackingSpace (anOrigin);
 789   }
 790 #endif
 791   myTrackOrigin = theOrigin;
 792 }
 793
 794 // =======================================================================
 795 // function : WaitPoses
 796 // purpose  :
 797 // =======================================================================
 798 bool Aspect_OpenVRSession::WaitPoses()
 799 {
 800 #ifdef HAVE_OPENVR
 801   if (myContext->System == NULL)
 802   {
 803     return false;
 804   }
 805
 806   switch (vr::VRCompositor()->GetTrackingSpace())
 807   {
 808     case vr::TrackingUniverseSeated:
 809       myTrackOrigin = TrackingUniverseOrigin_Seated;
 810       break;
 811     case vr::TrackingUniverseRawAndUncalibrated:
 812     case vr::TrackingUniverseStanding:
 813       myTrackOrigin = TrackingUniverseOrigin_Standing;
 814       break;
 815   }
 816
 817   const vr::EVRCompositorError aVRError = vr::VRCompositor()->WaitGetPoses (myContext->TrackedPoses, vr::k_unMaxTrackedDeviceCount, NULL, 0);
 818   if (aVRError != vr::VRCompositorError_None)
 819   {
 820     Message::SendTrace (TCollection_AsciiString ("Compositor wait poses error: ") + getVRCompositorError (aVRError));
 821   }
 822
 823   for (Standard_Integer aPoseIter = myTrackedPoses.Lower(); aPoseIter <= myTrackedPoses.Upper(); ++aPoseIter)
 824   {
 825     const vr::TrackedDevicePose_t& aVrPose = myContext->TrackedPoses[aPoseIter];
 826     myTrackedPoses[aPoseIter] = poseVr2Occ (aVrPose, myUnitFactor);
 827   }
 828
 829   if (myContext->TrackedPoses[vr::k_unTrackedDeviceIndex_Hmd].bPoseIsValid)
 830   {
 831     myHeadPose = myTrackedPoses[vr::k_unTrackedDeviceIndex_Hmd].Orientation;
 832     updateProjectionFrustums();
 833   }
 834   return aVRError != vr::VRCompositorError_None;
 835 #else
 836   return false;
 837 #endif
 838 }
 839
 840 // =======================================================================
 841 // function : GetDigitalActionData
 842 // purpose  :
 843 // =======================================================================
 844 Aspect_XRDigitalActionData Aspect_OpenVRSession::GetDigitalActionData (const Handle(Aspect_XRAction)& theAction) const
 845 {
 846   if (theAction.IsNull()
 847    || theAction->Type() != Aspect_XRActionType_InputDigital)
 848   {
 849     throw Standard_ProgramError("Aspect_OpenVRSession::GetDigitalActionData() called for wrong action");
 850   }
 851
 852   Aspect_XRDigitalActionData anActionData;
 853 #ifdef HAVE_OPENVR
 854   if (myContext->System != NULL
 855    && theAction->RawHandle() != 0)
 856   {
 857     vr::InputDigitalActionData_t aNewData = {};
 858     vr::EVRInputError anInErr = vr::VRInput()->GetDigitalActionData (theAction->RawHandle(), &aNewData, sizeof(aNewData), vr::k_ulInvalidInputValueHandle);
 859     if (anInErr != vr::VRInputError_None)
 860     {
 861       Message::SendFail (TCollection_AsciiString ("Input Error on '") + theAction->Id() + "': " + getVRInputError (anInErr));
 862       return anActionData;
 863     }
 864
 865     anActionData.IsActive     = aNewData.bActive;
 866     anActionData.IsChanged    = aNewData.bChanged;
 867     anActionData.IsPressed    = aNewData.bState;
 868     anActionData.UpdateTime   = aNewData.fUpdateTime;
 869     anActionData.ActiveOrigin = aNewData.activeOrigin;
 870   }
 871 #endif
 872   return anActionData;
 873 }
 874
 875 // =======================================================================
 876 // function : GetAnalogActionData
 877 // purpose  :
 878 // =======================================================================
 879 Aspect_XRAnalogActionData Aspect_OpenVRSession::GetAnalogActionData (const Handle(Aspect_XRAction)& theAction) const
 880 {
 881   if (theAction.IsNull()
 882    || theAction->Type() != Aspect_XRActionType_InputAnalog)
 883   {
 884     throw Standard_ProgramError("Aspect_OpenVRSession::GetAnalogActionData() called for wrong action");
 885   }
 886
 887   Aspect_XRAnalogActionData anActionData;
 888 #ifdef HAVE_OPENVR
 889   if (myContext->System != NULL
 890    && theAction->RawHandle() != 0)
 891   {
 892     vr::InputAnalogActionData_t aNewData = {};
 893     vr::EVRInputError anInErr = vr::VRInput()->GetAnalogActionData (theAction->RawHandle(), &aNewData, sizeof(aNewData), vr::k_ulInvalidInputValueHandle);
 894     if (anInErr != vr::VRInputError_None)
 895     {
 896       Message::SendFail (TCollection_AsciiString ("Input Error on '") + theAction->Id() + "': " + getVRInputError (anInErr));
 897       return anActionData;
 898     }
 899
 900     anActionData.IsActive = aNewData.bActive;
 901     anActionData.VecXYZ.SetValues (aNewData.x, aNewData.y, aNewData.z);
 902     anActionData.DeltaXYZ.SetValues (aNewData.deltaX, aNewData.deltaY, aNewData.deltaZ);
 903     anActionData.UpdateTime = aNewData.fUpdateTime;
 904     anActionData.ActiveOrigin = aNewData.activeOrigin;
 905   }
 906 #endif
 907   return anActionData;
 908 }
 909
 910 // =======================================================================
 911 // function : GetPoseActionDataForNextFrame
 912 // purpose  :
 913 // =======================================================================
 914 Aspect_XRPoseActionData Aspect_OpenVRSession::GetPoseActionDataForNextFrame (const Handle(Aspect_XRAction)& theAction) const
 915 {
 916   if (theAction.IsNull()
 917    || theAction->Type() != Aspect_XRActionType_InputPose)
 918   {
 919     throw Standard_ProgramError("Aspect_OpenVRSession::GetPoseActionDataForNextFrame() called for wrong action");
 920   }
 921
 922   Aspect_XRPoseActionData anActionData;
 923 #ifdef HAVE_OPENVR
 924   if (myContext->System != NULL
 925    && theAction->RawHandle() != 0)
 926   {
 927     vr::ETrackingUniverseOrigin anOrigin = vr::TrackingUniverseSeated;
 928     switch (myTrackOrigin)
 929     {
 930       case TrackingUniverseOrigin_Seated:   anOrigin = vr::TrackingUniverseSeated;   break;
 931       case TrackingUniverseOrigin_Standing: anOrigin = vr::TrackingUniverseStanding; break;
 932     }
 933     vr::InputPoseActionData_t aNewData = {};
 934     vr::EVRInputError anInErr = vr::VRInput()->GetPoseActionDataForNextFrame (theAction->RawHandle(), anOrigin, &aNewData, sizeof(aNewData), vr::k_ulInvalidInputValueHandle);
 935     if (anInErr != vr::VRInputError_None)
 936     {
 937       Message::SendFail (TCollection_AsciiString ("Input Error on '") + theAction->Id() + "': " + getVRInputError (anInErr));
 938       return anActionData;
 939     }
 940
 941     anActionData.Pose = poseVr2Occ (aNewData.pose, myUnitFactor);
 942     anActionData.IsActive = aNewData.bActive;
 943     anActionData.ActiveOrigin = aNewData.activeOrigin;
 944   }
 945 #endif
 946   return anActionData;
 947 }
 948
 949 // =======================================================================
 950 // function : triggerHapticVibrationAction
 951 // purpose  :
 952 // =======================================================================
 953 void Aspect_OpenVRSession::triggerHapticVibrationAction (const Handle(Aspect_XRAction)& theAction,
 954                                                          const Aspect_XRHapticActionData& theParams)
 955 {
 956   if (theAction.IsNull()
 957    || theAction->Type() != Aspect_XRActionType_OutputHaptic)
 958   {
 959     throw Standard_ProgramError("Aspect_OpenVRSession::triggerHapticVibrationAction() called for wrong action");
 960   }
 961
 962 #ifdef HAVE_OPENVR
 963   if (myContext->System != NULL
 964    && theAction->RawHandle() != 0)
 965   {
 966     Aspect_XRHapticActionData aParams = theParams;
 967     if (!theParams.IsValid())
 968     {
 969       // preset for aborting
 970       aParams.Duration  = 0.0f;
 971       aParams.Frequency = 1.0f;
 972       aParams.Amplitude = 0.1f;
 973     }
 974     vr::EVRInputError anInErr = vr::VRInput()->TriggerHapticVibrationAction (theAction->RawHandle(),
 975                                                                              aParams.Delay, aParams.Duration, aParams.Frequency, aParams.Amplitude,
 976                                                                              vr::k_ulInvalidInputValueHandle);
 977     if (anInErr != vr::VRInputError_None)
 978     {
 979       Message::SendFail (TCollection_AsciiString ("Output Error on '") + theAction->Id() + "': " + getVRInputError (anInErr));
 980     }
 981   }
 982 #else
 983   (void )theParams;
 984 #endif
 985 }
 986
 987 // =======================================================================
 988 // function : ProcessEvents
 989 // purpose  :
 990 // =======================================================================
 991 void Aspect_OpenVRSession::ProcessEvents()
 992 {
 993 #ifdef HAVE_OPENVR
 994   if (myContext->System == NULL)
 995   {
 996     return;
 997   }
 998
 999   // process OpenVR events
1000   vr::VREvent_t aVREvent = {};
1001   for (; myContext->PollNextEvent (aVREvent);)
1002   {
1003     switch (aVREvent.eventType)
1004     {
1005       case vr::VREvent_TrackedDeviceActivated:   onTrackedDeviceActivated  ((int )aVREvent.trackedDeviceIndex); break;
1006       case vr::VREvent_TrackedDeviceDeactivated: onTrackedDeviceDeactivated((int )aVREvent.trackedDeviceIndex); break;
1007       case vr::VREvent_TrackedDeviceUpdated:     onTrackedDeviceUpdated    ((int )aVREvent.trackedDeviceIndex); break;
1008     }
1009   }
1010
1011   // process OpenVR action state
1012   if (myActionSets.Extent() > 0)
1013   {
1014     NCollection_LocalArray<vr::VRActiveActionSet_t, 8> anActionSets (myActionSets.Extent());
1015     memset (anActionSets, 0, sizeof(vr::VRActiveActionSet_t) * myActionSets.Extent());
1016     for (Standard_Integer aSetIter = 0; aSetIter < myActionSets.Extent(); ++aSetIter)
1017     {
1018       anActionSets[aSetIter].ulActionSet = myActionSets.FindFromIndex (aSetIter + 1)->RawHandle();
1019     }
1020     vr::VRInput()->UpdateActionState (anActionSets, sizeof(vr::VRActiveActionSet_t), myActionSets.Extent());
1021   }
1022
1023   WaitPoses();
1024
1025   for (Aspect_XRActionSetMap::Iterator aSetIter (myActionSets); aSetIter.More(); aSetIter.Next())
1026   {
1027     const Handle(Aspect_XRActionSet)& anActionSet = aSetIter.Value();
1028     for (Aspect_XRActionMap::Iterator anActionIter (anActionSet->Actions()); anActionIter.More(); anActionIter.Next())
1029     {
1030       const Handle(Aspect_XRAction)& anAction = anActionIter.Value();
1031       if (anAction->RawHandle() == 0
1032        || anAction->Id().IsEmpty())
1033       {
1034         continue;
1035       }
1036
1037       switch (anAction->Type())
1038       {
1039         case Aspect_XRActionType_InputDigital:
1040         {
1041           Aspect_XRDigitalActionData aData = GetDigitalActionData (anAction);
1042           //if (aData.IsChanged) { std::cout << "  " << anAction->Id() << " pressed: " << aData.IsPressed << "\n"; }
1043           break;
1044         }
1045         case Aspect_XRActionType_InputAnalog:
1046         {
1047           Aspect_XRAnalogActionData aData = GetAnalogActionData (anAction);
1048           //if (aData.IsChanged()) { std::cout << "  " << anAction->Id() << " changed: " << aData.VecXYZ[0] << " " << aData.VecXYZ[1] << " " << aData.VecXYZ[2] << "\n"; }
1049           break;
1050         }
1051         case Aspect_XRActionType_InputPose:
1052         {
1053           GetPoseActionDataForNextFrame (anAction);
1054           break;
1055         }
1056       }
1057     }
1058   }
1059
1060   // process OpenVR controller state using deprecated API
1061   //for (vr::TrackedDeviceIndex_t aDevIter = 0; aDevIter < vr::k_unMaxTrackedDeviceCount; ++aDevIter) {
1062   //  vr::VRControllerState_t aCtrlState = {}; if (myContext->GetControllerState (aCtrlState, aDevIter)) { aCtrlState.ulButtonPressed == 0; }
1063   //}
1064 #endif
1065 }
1066
1067 // =======================================================================
1068 // function : onTrackedDeviceActivated
1069 // purpose  :
1070 // =======================================================================
1071 void Aspect_OpenVRSession::onTrackedDeviceActivated (Standard_Integer theDeviceIndex)
1072 {
1073   Message::SendTrace (TCollection_AsciiString ("OpenVR, Device ") + theDeviceIndex + " attached");
1074 }
1075
1076 // =======================================================================
1077 // function : onTrackedDeviceDeactivated
1078 // purpose  :
1079 // =======================================================================
1080 void Aspect_OpenVRSession::onTrackedDeviceDeactivated (Standard_Integer theDeviceIndex)
1081 {
1082   Message::SendTrace (TCollection_AsciiString ("OpenVR, Device ") + theDeviceIndex + " detached");
1083 }
1084
1085 // =======================================================================
1086 // function : onTrackedDeviceUpdated
1087 // purpose  :
1088 // =======================================================================
1089 void Aspect_OpenVRSession::onTrackedDeviceUpdated (Standard_Integer theDeviceIndex)
1090 {
1091   Message::SendTrace (TCollection_AsciiString ("OpenVR, Device ") + theDeviceIndex + " updated");
1092 }
1093
1094 // =======================================================================
1095 // function : SubmitEye
1096 // purpose  :
1097 // =======================================================================
1098 bool Aspect_OpenVRSession::SubmitEye (void* theTexture,
1099                                       Aspect_GraphicsLibrary theGraphicsLib,
1100                                       Aspect_ColorSpace theColorSpace,
1101                                       Aspect_Eye theEye)
1102 {
1103   if (theTexture == NULL)
1104   {
1105     return false;
1106   }
1107 #ifdef HAVE_OPENVR
1108   if (myContext->System == NULL)
1109   {
1110     return false;
1111   }
1112
1113   vr::Texture_t aVRTexture = { (void* )theTexture, vr::TextureType_OpenGL, vr::ColorSpace_Gamma };
1114   switch (theGraphicsLib)
1115   {
1116     case Aspect_GraphicsLibrary_OpenGL:
1117       aVRTexture.eType = vr::TextureType_OpenGL;
1118       break;
1119     default:
1120       Message::SendFail ("Compositor error: unsupported Graphics API");
1121       return false;
1122   }
1123   switch (theColorSpace)
1124   {
1125     case Aspect_ColorSpace_sRGB:   aVRTexture.eColorSpace = vr::ColorSpace_Gamma;  break;
1126     case Aspect_ColorSpace_Linear: aVRTexture.eColorSpace = vr::ColorSpace_Linear; break;
1127   }
1128
1129   const vr::EVRCompositorError aVRError = vr::VRCompositor()->Submit (theEye == Aspect_Eye_Right ? vr::Eye_Right : vr::Eye_Left, &aVRTexture);
1130   if (aVRError != vr::VRCompositorError_None)
1131   {
1132     if (aVRError != vr::VRCompositorError_AlreadySubmitted)
1133     {
1134       Message::SendFail (TCollection_AsciiString ("Compositor Error: ") + getVRCompositorError (aVRError));
1135     }
1136     else
1137     {
1138       Message::SendTrace (TCollection_AsciiString ("Compositor Error: ") + getVRCompositorError (aVRError));
1139     }
1140     return false;
1141   }
1142   return true;
1143 #else
1144   (void )theGraphicsLib;
1145   (void )theColorSpace;
1146   (void )theEye;
1147   return false;
1148 #endif
1149 }