vtkOpenXRManager.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkOpenXRManager_h
#define vtkOpenXRManager_h
 
#include "vtkABINamespace.h"
#include "vtkRenderingOpenXRModule.h" // needed for exports
 
#include "vtkNew.h"
#include "vtkOpenXR.h"
#include "vtkOpenXRManagerConnection.h"
#include "vtkOpenXRManagerGraphics.h"
#include "vtkOpenXRRenderWindow.h"
#include "vtkSmartPointer.h"
 
#include <array>
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
VTK_ABI_NAMESPACE_BEGIN
class vtkOpenGLRenderWindow;
class vtkOpenXRSceneObserver;
VTK_ABI_NAMESPACE_END
 
namespace vtk::detail
{
VTK_ABI_NAMESPACE_BEGIN
class VTKRENDERINGOPENXR_EXPORT vtkOpenXRManager
{
public:

  static vtkOpenXRManager& GetInstance()
  {
    static vtkOpenXRManager UniqueInstance;
    return UniqueInstance;
  }

 
  enum OutputLevel
  {
    DebugOutput = 0,
    WarningOutput = 1,
    ErrorOutput = 2
  };


  bool XrCheckOutput(OutputLevel level, const XrResult&, const std::string& message);


  void PrintInstanceProperties();
  void PrintSystemProperties(XrSystemProperties* system_properties);
  void PrintSupportedViewConfigs();
  void PrintViewConfigViewInfo(const std::vector<XrViewConfigurationView>&);
  bool PrintReferenceSpaces();


  bool Initialize(vtkOpenXRRenderWindow* xrWindow);


  void Finalize();


  std::tuple<uint32_t, uint32_t> GetRecommendedImageRectSize();


  uint32_t GetRecommendedSampleCount();

  uint32_t GetViewCount()
  {
    return static_cast<uint32_t>(this->RenderResources->ConfigViews.size());
  }


  std::string GetOpenXRPropertiesAsString();


  const XrPosef* GetViewPose(uint32_t eye)
  {
    if (eye >= this->GetViewCount())
    {
      return nullptr;
    }
    return &(this->RenderResources->Views[eye].pose);
  }



  const XrFovf* GetProjectionFov(uint32_t eye)
  {
    if (eye >= this->GetViewCount())
    {
      return nullptr;
    }
    return &(this->RenderResources->Views[eye].fov);
  }



  bool IsDepthExtensionSupported() { return this->OptionalExtensions.DepthExtensionSupported; }

  bool IsSceneUnderstandingSupported()
  {
    return this->OptionalExtensions.SceneUnderstandingSupported;
  }


  bool GetShouldRenderCurrentFrame() { return this->ShouldRenderCurrentFrame; }


  bool BeginSession();


  const XrSession& GetSession() { return this->Session; }


  const XrInstance& GetXrRuntimeInstance() { return this->Instance; }


  bool IsSessionRunning() { return this->SessionRunning; }


  bool WaitAndBeginFrame();


  bool PrepareRendering(vtkOpenXRRenderWindow* win, void* colorTextureId, void* depthTextureId);


  void ReleaseSwapchainImage(uint32_t eye);


  bool EndFrame();


  bool PollEvent(XrEventDataBuffer& eventData);


  XrPath GetXrPath(const std::string& path);
 
  const std::array<XrPath, 2>& GetSubactionPaths() { return this->SubactionPaths; }


  bool CreateActionSet(const std::string& actionSetName, const std::string& localizedActionSetName);


  bool SelectActiveActionSet(unsigned int index);


  bool AttachSessionActionSets();


  void DestroyActionSets();
 
  struct Action_t;


  bool CreateOneAction(
    Action_t& actionT, const std::string& name, const std::string& localizedName);


  bool SuggestActions(
    const std::string& profile, std::vector<XrActionSuggestedBinding>& actionSuggestedBindings);


  bool SyncActions();


  bool UpdateActionData(Action_t& action_t, int hand);

  bool ApplyVibration(const Action_t& actionT, int hand, float amplitude = 0.5,
    float duration = 25000000.0, float frequency = XR_FREQUENCY_UNSPECIFIED);
 
  enum ControllerIndex
  {
    Inactive = -1,
    Left = 0,
    Right = 1,
    Head = 2,
    Generic = 3,
    NumberOfControllers = 4
  };
 
  struct Action_t
  {
    XrAction Action;
    XrActionType ActionType;
 
    union
    {
      XrActionStateFloat _float;
      XrActionStateBoolean _boolean;
      XrActionStatePose _pose;
      XrActionStateVector2f _vec2f;
    } States[ControllerIndex::NumberOfControllers];
 
    XrSpace PoseSpaces[ControllerIndex::NumberOfControllers];
    XrSpaceLocation PoseLocations[ControllerIndex::NumberOfControllers];
    XrSpaceVelocity PoseVelocities[ControllerIndex::NumberOfControllers];
  };


  void SetGraphicsStrategy(vtkOpenXRManagerGraphics* gs) { this->GraphicsStrategy = gs; }
  vtkOpenXRManagerGraphics* GetGraphicsStrategy() { return this->GraphicsStrategy; }


  void SetConnectionStrategy(vtkOpenXRManagerConnection* cs) { this->ConnectionStrategy = cs; }
  vtkOpenXRManagerConnection* GetConnectionStrategy() { return this->ConnectionStrategy; }

  XrSystemId GetSystemID() const { return this->SystemId; }

  XrSpace GetReferenceSpace() const { return this->ReferenceSpace; }

  XrTime GetPredictedDisplayTime() const { return this->PredictedDisplayTime; }
 
protected:
  vtkOpenXRManager();
  ~vtkOpenXRManager() = default;


  bool CreateInstance(vtkOpenXRRenderWindow* window);
  std::vector<const char*> SelectExtensions(vtkOpenXRRenderWindow* window);


  void PrintOptionalExtensions();


  bool CreateSystem();


  bool CreateSystemProperties();


  bool CreateSession();


  bool CreateSwapchains();


  bool CreateConfigViews();


  std::tuple<int64_t, int64_t> SelectSwapchainPixelFormats();
 
  struct Swapchain_t;


  Swapchain_t CreateSwapchain(int64_t format, uint32_t width, uint32_t height, uint32_t sampleCount,
    XrSwapchainCreateFlags createFlags, XrSwapchainUsageFlags usageFlags);


  bool CreateReferenceSpace();
 
  bool LoadControllerModels();


  bool CreateOneActionSpace(const XrAction& action, const XrPath& subactionPath,
    const XrPosef& poseInActionSpace, XrSpace& space);


  bool CreateSubactionPaths();


  uint32_t WaitAndAcquireSwapchainImage(const XrSwapchain& swapchainHandle);
 
  // Currently VTK only supports HeadMountedDisplay (HMD)
  constexpr static XrFormFactor FormFactor = XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY;
 
  // Pick the view type to be stereo rather than mono or anything else
  constexpr static XrViewConfigurationType ViewType = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO;
 
  // PRIMARY_STEREO view configuration always has 2 views
  constexpr static uint32_t StereoViewCount = 2;
 
  // Three available types: VIEW, LOCAL and STAGE.  We use LOCAL space which
  // establishes a world-locked origin, rather than VIEW space, which tracks the
  // view origin.
  XrReferenceSpaceType ReferenceSpaceType = XR_REFERENCE_SPACE_TYPE_STAGE;
 
  // Communication with the runtime happens through this instance
  XrInstance Instance;
 
  // A system is defined by an id and is used to create a session
  XrSystemId SystemId;
 
  XrSession Session;
  XrSessionState SessionState;
  XrSpace ReferenceSpace;
 
  // At the end of a frame, we must select en environment blend mode
  // to tell the runtime how we want to blend the image with the user's
  // view of the physical world. For example, in VR, we will generally
  // choose XR_ENVIRONMENT_BLEND_MODE_OPAQUE while AR will generally
  // choose XR_ENVIRONMENT_BLEND_MODE_ADDITIVE or XR_ENVIRONMENT_BLEND_MODE_ALPHA_BLEND
  XrEnvironmentBlendMode EnvironmentBlendMode;
 
  // Non optional extension
  bool RenderingBackendExtensionSupported = false;


  struct
  {
    bool DepthExtensionSupported{ false };
    bool ControllerModelExtensionSupported{ false };
    bool UnboundedRefSpaceSupported{ false };
    bool SpatialAnchorSupported{ false };
    bool HandInteractionSupported{ false };
    bool HandTrackingSupported{ false };
    bool RemotingSupported{ false };
    bool SceneUnderstandingSupported{ false };
    bool SceneMarkerSupported{ false };
  } OptionalExtensions;

  struct Swapchain_t
  {
    XrSwapchain Swapchain;
    int64_t Format{ 0 };
    uint32_t Width{ 0 };
    uint32_t Height{ 0 };
  };


  struct RenderResources_t
  {
    XrViewState ViewState{ XR_TYPE_VIEW_STATE };
    // Each physical Display/Eye is described by a view
    std::vector<XrView> Views;
    // One configuration view per view : this store
    std::vector<XrViewConfigurationView> ConfigViews;
 
    std::vector<Swapchain_t> ColorSwapchains;
    std::vector<Swapchain_t> DepthSwapchains;
 
    std::vector<XrCompositionLayerProjectionView> ProjectionLayerViews;
    std::vector<XrCompositionLayerDepthInfoKHR> DepthInfoViews;
  };
  std::unique_ptr<RenderResources_t> RenderResources;
 
  // There is one subaction path for each hand.
  std::array<XrPath, 2> SubactionPaths;
 
  std::vector<XrActionSet> ActionSets;
  XrActionSet* ActiveActionSet = nullptr;

  XrTime PredictedDisplayTime;
 
  bool SessionRunning = false;
  // Following each WaitAndBeginFrame operation, the OpenXR runtime may indicate
  // whether the current frame should be rendered using the `XrFrameState.shouldRender`
  // property. We store this information to optimize rendering and prevent unnecessary
  // render calls. For further details, refer to:
  // https://registry.khronos.org/OpenXR/specs/1.0/man/html/XrFrameState.html
  bool ShouldRenderCurrentFrame = false;
  // If true, the function UpdateActionData will store
  // pose velocities for pose actions
  bool StorePoseVelocities = false;
 
  vtkSmartPointer<vtkOpenXRManagerGraphics> GraphicsStrategy;
 
  vtkSmartPointer<vtkOpenXRManagerConnection> ConnectionStrategy;
 
private:
  vtkOpenXRManager(const vtkOpenXRManager&) = delete;
  void operator=(const vtkOpenXRManager&) = delete;
};
VTK_ABI_NAMESPACE_END
} // namespace vtk::detail
 
#endif
// VTK-HeaderTest-Exclude: vtkOpenXRManager.h