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 "vtkRenderingOpenXRModule.h" // needed for exports
 
#include "vtkNew.h"
#include "vtkOpenXR.h"
#include "vtkOpenXRManagerConnection.h"
#include "vtkOpenXRManagerGraphics.h"
#include "vtkSmartPointer.h"
 
#include <array>
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
VTK_ABI_NAMESPACE_BEGIN
class vtkOpenGLRenderWindow;
class vtkOpenXRRenderWindow;
class vtkOpenXRSceneObserver;
 
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);
 
  struct VTKRENDERINGOPENXR_EXPORT InstanceVersion
  {
    std::uint16_t Major{};
    std::uint16_t Minor{};
    std::uint32_t Patch{};
  };
 
  static InstanceVersion QueryInstanceVersion(vtkOpenXRManagerConnection* cs);
 
 
  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; }
 
  VTK_DEPRECATED_IN_9_5_0(
    "Use vtkOpenXRRenderWindow::SetUseDepthExtension instead. This has no effect!")
  void SetUseDepthExtension(bool) {}
  VTK_DEPRECATED_IN_9_5_0(
    "Use vtkOpenXRRenderWindow::GetUseDepthExtension instead. This returns false!")
  bool GetUseDepthExtension() const { return false; }
 
  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
#endif
// VTK-HeaderTest-Exclude: vtkOpenXRManager.h