Add OpenXRRemoting support

CMakeLists.txt

@@ -51,6 +51,29 @@ message(STATUS "")
 message(STATUS "Setting SlicerVirtualReality_HAS_OPENXR_SUPPORT to ${SlicerVirtualReality_HAS_OPENXR_SUPPORT}${_reason}")
 message(STATUS "")
 
+# OpenXRRemoting
+set(_default OFF)
+set(_reason)
+if(NOT DEFINED SlicerVirtualReality_HAS_OPENXRREMOTING_SUPPORT)
+  if(WIN32)
+    if(NOT SlicerVirtualReality_HAS_OPENXR_SUPPORT)
+      set(_default OFF)
+      set(_reason " (OpenXR support was disabled)")
+    else()
+      set(_default ON)
+      set(_reason " (OpenXRRemoting is supported on Windows)")
+    endif()
+  else()
+    set(_default OFF)
+    set(_reason " (OpenXRRemoting is not supported on this platform)")
+  endif()
+endif()
+option(SlicerVirtualReality_HAS_OPENXRREMOTING_SUPPORT "Build OpenXR Remoting support" ${_default})
+mark_as_superbuild(SlicerVirtualReality_HAS_OPENXRREMOTING_SUPPORT)
+message(STATUS "")
+message(STATUS "Setting SlicerVirtualReality_HAS_OPENXRREMOTING_SUPPORT to ${SlicerVirtualReality_HAS_OPENXRREMOTING_SUPPORT}${_reason}")
+message(STATUS "")
+
 #-----------------------------------------------------------------------------
 # SuperBuild setup
 option(${EXTENSION_NAME}_SUPERBUILD "Build ${EXTENSION_NAME} and the projects it depends on." ON)
@@ -101,6 +124,12 @@ if(SlicerVirtualReality_HAS_OPENXR_SUPPORT)
   set(vtkRenderingOpenXR_DIR \"${vtkRenderingOpenXR_DIR}\")
   find_package(vtkRenderingOpenXR REQUIRED)
 endif()
+
+set(SlicerVirtualReality_HAS_OPENXRREMOTING_SUPPORT ${SlicerVirtualReality_HAS_OPENXRREMOTING_SUPPORT})
+if(SlicerVirtualReality_HAS_OPENXRREMOTING_SUPPORT)
+  set(vtkRenderingOpenXRRemoting_DIR \"${vtkRenderingOpenXRRemoting_DIR}\")
+  find_package(vtkRenderingOpenXRRemoting REQUIRED)
+endif()
 ##################################################
 ")
 include(${Slicer_EXTENSION_GENERATE_CONFIG})
@@ -165,25 +194,64 @@ endif()
 #-----------------------------------------------------------------------------
 set(EXTENSION_CPACK_INSTALL_CMAKE_PROJECTS)
 
+# vtkRenderingVR
 list(APPEND EXTENSION_CPACK_INSTALL_CMAKE_PROJECTS "${vtkRenderingVR_DIR};vtkRenderingVR;runtime;/")
 if(Slicer_USE_PYTHONQT)
   list(APPEND EXTENSION_CPACK_INSTALL_CMAKE_PROJECTS "${vtkRenderingVR_DIR};vtkRenderingVR;python;/")
 endif()
 
+# vtkRenderingOpenVR
 if(SlicerVirtualReality_HAS_OPENVR_SUPPORT)
   list(APPEND EXTENSION_CPACK_INSTALL_CMAKE_PROJECTS "${vtkRenderingOpenVR_DIR};vtkRenderingOpenVR;runtime;/")
   if(Slicer_USE_PYTHONQT)
     list(APPEND EXTENSION_CPACK_INSTALL_CMAKE_PROJECTS "${vtkRenderingOpenVR_DIR};vtkRenderingOpenVR;python;/")
   endif()
 endif()
 
+# vtkRenderingOpenXR
 if(SlicerVirtualReality_HAS_OPENXR_SUPPORT)
   list(APPEND EXTENSION_CPACK_INSTALL_CMAKE_PROJECTS "${vtkRenderingOpenXR_DIR};vtkRenderingOpenXR;runtime;/")
   if(Slicer_USE_PYTHONQT)
     list(APPEND EXTENSION_CPACK_INSTALL_CMAKE_PROJECTS "${vtkRenderingOpenXR_DIR};vtkRenderingOpenXR;python;/")
   endif()
 endif()
 
+# vtkRenderingOpenXRRemoting
+if(SlicerVirtualReality_HAS_OPENXRREMOTING_SUPPORT)
+  list(APPEND EXTENSION_CPACK_INSTALL_CMAKE_PROJECTS "${vtkRenderingOpenXRRemoting_DIR};vtkRenderingOpenXRRemoting;runtime;/")
+  if(Slicer_USE_PYTHONQT)
+    list(APPEND EXTENSION_CPACK_INSTALL_CMAKE_PROJECTS "${vtkRenderingOpenXRRemoting_DIR};vtkRenderingOpenXRRemoting;python;/")
+  endif()
+
+  # OpenXRRemoting: RemotingXR.json and companion files are copied or installed along side the
+  # vtkRenderingRemotingOpenXR library so that "vtkOpenXRManagerRemoteConnection::Initialize()"
+  # can locate the files and set the XR_RUNTIME_JSON env. variable
+  set(OpenXRRemoting_FILES )
+  if(WIN32)
+    set(OpenXRRemoting_FILES
+      Microsoft.Holographic.AppRemoting.OpenXr.dll
+      Microsoft.Holographic.AppRemoting.OpenXr.SU.dll
+      PerceptionDevice.dll
+      RemotingXR.json
+      )
+  endif()
+  set(_dest ${CMAKE_BINARY_DIR}/${Slicer_THIRDPARTY_BIN_DIR})
+  foreach(file IN LISTS OpenXRRemoting_FILES)
+    # Copy
+    message(STATUS "Copying ${file} to ${_dest}")
+    file(COPY ${OpenXRRemoting_BIN_DIR}/${file}
+      DESTINATION ${_dest}
+      USE_SOURCE_PERMISSIONS
+      )
+    # Install
+    install(FILES ${OpenXRRemoting_BIN_DIR}/${file}
+      DESTINATION ${Slicer_INSTALL_THIRDPARTY_LIB_DIR}
+      COMPONENT RuntimeLibraries
+      )
+  endforeach()
+
+endif()
+
 set(${EXTENSION_NAME}_CPACK_INSTALL_CMAKE_PROJECTS "${EXTENSION_CPACK_INSTALL_CMAKE_PROJECTS}" CACHE STRING "List of external projects to install" FORCE)
 
 #-----------------------------------------------------------------------------

SuperBuild/External_OpenXRRemoting.cmake

@@ -0,0 +1,74 @@
+
+set(proj OpenXRRemoting)
+
+set(${proj}_DEPENDENCIES "")
+
+# Include dependent projects if any
+ExternalProject_Include_Dependencies(${proj} PROJECT_VAR proj DEPENDS_VAR ${proj}_DEPENDENCIES)
+
+if(${SUPERBUILD_TOPLEVEL_PROJECT}_USE_SYSTEM_${proj})
+  message(FATAL_ERROR "Enabling ${SUPERBUILD_TOPLEVEL_PROJECT}_USE_SYSTEM_${proj} is not supported !")
+endif()
+
+# Sanity checks
+if(DEFINED OpenXRRemoting_BIN_DIR AND NOT EXISTS ${OpenXRRemoting_BIN_DIR})
+  message(FATAL_ERROR "OpenXRRemoting_BIN_DIR variable is defined but corresponds to nonexistent directory")
+endif()
+if(DEFINED OpenXRRemoting_INCLUDE_DIR AND NOT EXISTS ${OpenXRRemoting_INCLUDE_DIR})
+  message(FATAL_ERROR "OpenXRRemoting_INCLUDE_DIR variable is defined but corresponds to nonexistent path")
+endif()
+
+if((NOT OpenXRRemoting_BIN_DIR OR NOT OpenXRRemoting_INCLUDE_DIR)
+   AND NOT ${SUPERBUILD_TOPLEVEL_PROJECT}_USE_SYSTEM_${proj})
+
+  set(EP_INSTALL_DIR ${CMAKE_BINARY_DIR}/${proj}-install)
+
+  set(_ver "2.9.3")
+  set(_sha256 "9ef533aeff9ddef40104ad0d03e1e631c314729b18690385a4a624fab2408797")
+
+  ExternalProject_Add(${proj}
+    ${${proj}_EP_ARGS}
+    URL "https://www.nuget.org/api/v2/package/Microsoft.Holographic.Remoting.OpenXr/${_ver}"
+    URL_HASH "SHA256=${_sha256}"
+    SOURCE_DIR ${EP_INSTALL_DIR}
+    BUILD_IN_SOURCE 1
+    CONFIGURE_COMMAND ""
+    BUILD_COMMAND ""
+    INSTALL_COMMAND ""
+    DEPENDS
+      ${${proj}_DEPENDENCIES}
+    )
+
+  set(OpenXRRemoting_BIN_DIR "${EP_INSTALL_DIR}/build/native/bin/x64/Desktop/")
+  set(OpenXRRemoting_INCLUDE_DIR "${EP_INSTALL_DIR}/build/native/include/openxr/")
+
+  #-----------------------------------------------------------------------------
+  # Launcher setting specific to build tree
+
+  # library paths
+  set(${proj}_LIBRARY_PATHS_LAUNCHER_BUILD
+    ${OpenXRRemoting_BIN_DIR}
+    )
+  mark_as_superbuild(
+    VARS ${proj}_LIBRARY_PATHS_LAUNCHER_BUILD
+    LABELS "LIBRARY_PATHS_LAUNCHER_BUILD"
+    )
+
+  #-----------------------------------------------------------------------------
+  # Launcher setting specific to install tree
+
+  # NA
+
+else()
+  ExternalProject_Add_Empty(${proj} DEPENDS ${${proj}_DEPENDS})
+endif()
+
+ExternalProject_Message(${proj} "OpenXRRemoting_BIN_DIR:${OpenXRRemoting_BIN_DIR}")
+ExternalProject_Message(${proj} "OpenXRRemoting_INCLUDE_DIR:${OpenXRRemoting_INCLUDE_DIR}")
+
+mark_as_superbuild(
+  VARS
+    OpenXRRemoting_BIN_DIR:PATH
+    OpenXRRemoting_INCLUDE_DIR:PATH
+  )
+

SuperBuild/External_vtkRenderingOpenXRRemoting.cmake

@@ -0,0 +1,118 @@
+#-----------------------------------------------------------------------------
+# Build VTK Rendering OpenXRRemoting module, pointing it to Slicer's VTK and the vtkRenderingOpenXR
+# module also built by this extension.
+
+set(proj vtkRenderingOpenXRRemoting)
+
+# Set dependency list
+set(${proj}_DEPENDS
+  vtkRenderingOpenXR
+  OpenXRRemoting
+  )
+
+# Include dependent projects if any
+ExternalProject_Include_Dependencies(${proj} PROJECT_VAR proj)
+
+if(${SUPERBUILD_TOPLEVEL_PROJECT}_USE_SYSTEM_${proj})
+  message(FATAL_ERROR "Enabling ${SUPERBUILD_TOPLEVEL_PROJECT}_USE_SYSTEM_${proj} is not supported !")
+endif()
+
+# Sanity checks
+if(DEFINED ${proj}_DIR AND NOT EXISTS ${${proj}_DIR})
+  message(FATAL_ERROR "${proj}_DIR [${${proj}_DIR}] variable is defined but corresponds to nonexistent directory")
+endif()
+
+if(NOT DEFINED ${proj}_DIR AND NOT ${SUPERBUILD_TOPLEVEL_PROJECT}_USE_SYSTEM_${proj})
+
+  set(EXTERNAL_PROJECT_OPTIONAL_CMAKE_CACHE_ARGS)
+  if(VTK_WRAP_PYTHON)
+    list(APPEND EXTERNAL_PROJECT_OPTIONAL_CMAKE_CACHE_ARGS
+      -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}
+      -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR}
+      -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY}
+      # Required by FindPython3 CMake module used by VTK
+      -DPython3_ROOT_DIR:PATH=${Python3_ROOT_DIR}
+      -DPython3_INCLUDE_DIR:PATH=${Python3_INCLUDE_DIR}
+      -DPython3_LIBRARY:FILEPATH=${Python3_LIBRARY}
+      -DPython3_LIBRARY_DEBUG:FILEPATH=${Python3_LIBRARY_DEBUG}
+      -DPython3_LIBRARY_RELEASE:FILEPATH=${Python3_LIBRARY_RELEASE}
+      -DPython3_EXECUTABLE:FILEPATH=${Python3_EXECUTABLE}
+      )
+  endif()
+
+  if(NOT EXISTS ${VTKExternalModule_SOURCE_DIR})
+    message(FATAL_ERROR "VTKExternalModule_SOURCE_DIR [${VTKExternalModule_SOURCE_DIR}] variable is set to a nonexistent directory")
+  endif()
+
+  set(VTK_SOURCE_DIR ${VTK_DIR}/../VTK)
+  ExternalProject_Message(${proj} "VTK_SOURCE_DIR:${VTK_SOURCE_DIR}")
+
+  set(_module_subdir Rendering/OpenXRRemoting)
+  set(_module_name RenderingOpenXRRemoting)
+
+  set(EP_SOURCE_DIR ${VTK_SOURCE_DIR}/${_module_subdir})
+  set(EP_BINARY_DIR ${CMAKE_BINARY_DIR}/${proj}-build)
+
+  ExternalProject_Add(${proj}
+    ${${proj}_EP_ARGS}
+    DOWNLOAD_COMMAND ""
+    SOURCE_DIR ${VTKExternalModule_SOURCE_DIR}
+    BINARY_DIR ${EP_BINARY_DIR}
+    INSTALL_COMMAND ""
+    CMAKE_CACHE_ARGS
+      # VTKExternalModule
+      -DVTK_MODULE_NAME:STRING=${_module_name}
+      -DVTK_MODULE_SOURCE_DIR:PATH=${EP_SOURCE_DIR}
+      -DVTK_MODULE_CMAKE_MODULE_PATH:PATH=${VTK_SOURCE_DIR}/CMake
+      # vtkRenderingOpenXRRemoting
+      -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
+      -DCMAKE_CXX_FLAGS:STRING=${ep_common_cxx_flags}
+      -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
+      -DCMAKE_C_FLAGS:STRING=${ep_common_c_flags}
+      -DBUILD_TESTING:BOOL=OFF
+      -DCMAKE_RUNTIME_OUTPUT_DIRECTORY:PATH=${CMAKE_BINARY_DIR}/${Slicer_THIRDPARTY_BIN_DIR}
+      -DCMAKE_LIBRARY_OUTPUT_DIRECTORY:PATH=${CMAKE_BINARY_DIR}/${Slicer_THIRDPARTY_LIB_DIR}
+      -DCMAKE_INSTALL_BINDIR:STRING=${Slicer_INSTALL_THIRDPARTY_BIN_DIR}
+      -DCMAKE_INSTALL_LIBDIR:STRING=${Slicer_INSTALL_THIRDPARTY_LIB_DIR}
+      -DCMAKE_MACOSX_RPATH:BOOL=0
+      # Required to find VTK
+      -DVTK_DIR:PATH=${VTK_DIR}
+      # Required to find vtkRenderingOpenXRRemoting
+      -DvtkRenderingVR_DIR:PATH=${vtkRenderingVR_DIR}
+      -DvtkRenderingOpenXR_DIR:PATH=${vtkRenderingOpenXR_DIR}
+      # Required to find OpenXRRemoting
+      -DOpenXRRemoting_BIN_DIR:PATH=${OpenXRRemoting_BIN_DIR}
+      -DOpenXRRemoting_INCLUDE_DIR:PATH=${OpenXRRemoting_INCLUDE_DIR}
+      ${EXTERNAL_PROJECT_OPTIONAL_CMAKE_CACHE_ARGS}
+    DEPENDS
+      ${${proj}_DEPENDS}
+    )
+
+  ExternalProject_AlwaysConfigure(${proj})
+
+  set(${proj}_DIR ${EP_BINARY_DIR})
+
+  #-----------------------------------------------------------------------------
+  # Launcher setting specific to build tree
+
+  # pythonpath
+  set(${proj}_PYTHONPATH_LAUNCHER_BUILD
+    ${${proj}_DIR}/${Slicer_INSTALL_THIRDPARTY_LIB_DIR}/${PYTHON_SITE_PACKAGES_SUBDIR}/vtkmodules
+    )
+  mark_as_superbuild(
+    VARS ${proj}_PYTHONPATH_LAUNCHER_BUILD
+    LABELS "PYTHONPATH_LAUNCHER_BUILD"
+    )
+
+  #-----------------------------------------------------------------------------
+  # Launcher setting specific to install tree
+
+  # NA
+
+else()
+  ExternalProject_Add_Empty(${proj} DEPENDS ${${proj}_DEPENDS})
+endif()
+
+mark_as_superbuild(VARS ${proj}_DIR:PATH)
+ExternalProject_Message(${proj} "${proj}_DIR:${${proj}_DIR}")
+

SuperBuildPrerequisites.cmake

@@ -15,6 +15,9 @@ endif()
 if(NOT DEFINED SlicerVirtualReality_HAS_OPENXR_SUPPORT)
   message(FATAL_ERROR "SlicerVirtualReality_HAS_OPENXR_SUPPORT is not set")
 endif()
+if(NOT DEFINED SlicerVirtualReality_HAS_OPENXRREMOTING_SUPPORT)
+  message(FATAL_ERROR "SlicerVirtualReality_HAS_OPENXRREMOTING_SUPPORT is not set")
+endif()
 
 # Set list of dependencies to ensure the custom application bundling this
 # extension does NOT automatically collect the project list and attempt to
@@ -48,6 +51,11 @@ else()
       vtkRenderingOpenXR
       )
   endif()
+  if(SlicerVirtualReality_HAS_OPENXRREMOTING_SUPPORT)
+    list(APPEND SlicerVirtualReality_EXTERNAL_PROJECT_DEPENDENCIES
+      vtkRenderingOpenXRRemoting
+      )
+  endif()
 endif()
 message(STATUS "SlicerVirtualReality_EXTERNAL_PROJECT_DEPENDENCIES:${SlicerVirtualReality_EXTERNAL_PROJECT_DEPENDENCIES}")
 
@@ -58,6 +66,7 @@ if(NOT DEFINED Slicer_SOURCE_DIR)
   # - vtkRenderingVR
   # - vtkRenderingOpenVR
   # - vtkRenderingOpenXR
+  # - vtkRenderingOpenXRRemoting
   include(${SlicerVirtualReality_SOURCE_DIR}/FetchVTKExternalModule.cmake)
 
 else()
@@ -89,12 +98,18 @@ else()
   else()
     set(VTK_MODULE_ENABLE_VTK_RenderingOpenXR NO)
   endif()
+  if(SlicerVirtualReality_HAS_OPENXRREMOTING_SUPPORT)
+    set(VTK_MODULE_ENABLE_VTK_RenderingOpenXRRemoting YES)
+  else()
+    set(VTK_MODULE_ENABLE_VTK_RenderingOpenXRRemoting NO)
+  endif()
 
   mark_as_superbuild(
     VARS
       VTK_MODULE_ENABLE_VTK_RenderingVR:STRING
       VTK_MODULE_ENABLE_VTK_RenderingOpenVR:STRING
       VTK_MODULE_ENABLE_VTK_RenderingOpenXR:STRING
+      VTK_MODULE_ENABLE_VTK_RenderingOpenXRRemoting:STRING
     PROJECTS
       VTK
     )

VirtualReality/CMakeLists.txt

@@ -13,6 +13,9 @@ endif()
 if(SlicerVirtualReality_HAS_OPENXR_SUPPORT)
   find_package(vtkRenderingOpenXR REQUIRED)
 endif()
+if(SlicerVirtualReality_HAS_OPENXRREMOTING_SUPPORT)
+  find_package(vtkRenderingOpenXRRemoting REQUIRED)
+endif()
 
 #-----------------------------------------------------------------------------
 add_subdirectory(MRML)

VirtualReality/MRML/CMakeLists.txt

@@ -37,6 +37,11 @@ if(SlicerVirtualReality_HAS_OPENXR_SUPPORT)
     VTK::RenderingOpenXR
     )
 endif()
+if(SlicerVirtualReality_HAS_OPENXRREMOTING_SUPPORT)
+  list(APPEND ${KIT}_TARGET_LIBRARIES
+    VTK::RenderingOpenXRRemoting
+    )
+endif()
 
 #-----------------------------------------------------------------------------
 SlicerMacroBuildModuleMRML(

VirtualReality/MRML/vtkMRMLVirtualRealityConfigure.h.in

@@ -3,5 +3,6 @@
 
 #cmakedefine SlicerVirtualReality_HAS_OPENVR_SUPPORT
 #cmakedefine SlicerVirtualReality_HAS_OPENXR_SUPPORT
+#cmakedefine SlicerVirtualReality_HAS_OPENXRREMOTING_SUPPORT
 
 #endif