DtVarjoProvider.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2022 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/

#pragma once



#include "vrvVirtualReality/vrvVirtualReality.h"
#include "vrvVirtualReality/DtVirtualRealityProvider.h"

#include <vrvUtil/DtQuat.h>
#include <matrix/vlVector.h>

#include <osg/Matrixd>
#include <osg/RenderInfo>

#include <vrvOsg/DtVariableRateShadingImage.h>
#include <vrvOsg/DtVariableRateShadingImageUpdater.h>

#include <array>
#include <string>
#include <thread>

#include <Varjo.h>
#include <Varjo_events.h>
#include <Varjo_layers.h>
#include <Varjo_mr.h>
#include <Varjo_world.h>


#define VARJO_USE_GAZE 1

namespace makVrv
{

   class DtVirtualRealityChannel;
   class DtVrsGazeMapUpdater;
   class DtVarjoBeginFrameCallback;
   class DtVarjoWaitForSyncThread;


   class DT_DLL_VRVVR DtVarjoProvider : public DtVirtualRealityProvider
   {
   public:
      friend DtVarjoBeginFrameCallback;
      friend DtVarjoWaitForSyncThread;

      struct ViewSettings
      {
         ViewSettings(): myNearClip(1), myFarClip(10)
         {
            //intentional nop
         }

         double myNearClip;
         double myFarClip;
      };

   public:
      DtVarjoProvider(DtDe& de);

      virtual ~DtVarjoProvider();

   private:
      DtVarjoProvider();

      DtVarjoProvider(const DtVarjoProvider&);

      DtVarjoProvider& operator=(const DtVarjoProvider&);

   public:

      virtual DtSubmitOverlayCallback* createOverlayCallback(osg::Texture* tex, DtDe& de, DtVirtualRealityDriver& driver);

      virtual DtSubmitViewCallback* createViewCallback(DtVirtualRealityPostProcessor& pp, DtVirtualRealityDriver& driver, vrvVirtualReality::DtEye eye);

      virtual DtBeginFrameCallback* createBeginFrameCallback(DtVirtualRealityDriver& driver, vrvVirtualReality::DtEye eye);

      virtual const std::string& providerName();

      virtual const std::string& deviceName();

      virtual bool initializeVR();

      virtual bool hasFocusViews();

      virtual bool useVrs();

      virtual DtVariableRateShadingImageUpdater* findVrsUpdater(DtVirtualRealityChannel* channel);

      virtual void getRecommendedRenderTargetSize(int& width, int& height, vrvVirtualReality::DtEye whichEye);

      virtual DtSwapChain* allocateSwapChain(vrvVirtualReality::DtEye whichEye, bool isOverlay);

      virtual void getProjectionAngles(vrvVirtualReality::DtEye eye, double& left, double& right, double& bottom, double& top, double znear, double zfar);

      virtual osg::Matrixd getEyeToHeadTransform(vrvVirtualReality::DtEye eye);

      virtual void commitEyeTexture(osg::RenderInfo& renderInfo, DtSwapChain* swapChain);

      virtual void commitHudTexture(osg::RenderInfo& renderInfo, DtSwapChain* swapChain);

      virtual void updateOverlayDimensions(float width, float height, float distance, int pixWidth, int pixHeight);

      virtual void tick();

      virtual bool getHmdPose(DtVector& pos, DtQuat& ori);

      virtual void setHmdPoseOffset(const DtVector& pos, const DtQuat& ori);

      virtual bool getTrackedPose(DtVector& pos, DtQuat& ori, int index);

      virtual const std::unordered_map<int64_t, DtTrackedMarker>& getTrackedMarkers() const;

      virtual bool reset();

      virtual void triggerAction1();

      virtual bool shutdown();

      virtual bool hasTrackedCamera();

      virtual DtTrackedCamera* findTrackedCamera();

      virtual DtMixedRealityMask* findMixedRealityMask();

      virtual vrvVirtualReality::DtVrOverlayMode overlayMode();

      virtual void startMixedReality();

      virtual void stopMixedReality();

      virtual bool supportsMixedReality();

      virtual bool supportsDepthBufferSubmission();

      virtual bool supportsRealWorldDepthTesting();

      virtual void startRealWorldDepthTesting();

      virtual void stopRealWorldDepthTesting();

      void setOverlayEnabled(bool enabled);

      // need to do this to turn on mr
      void calibrateEyeTracking();


      varjo_Session* findVarjoSystem() const;

   public:

      static bool isVrAvailable();

   protected:

      void invokeWaitForSyncOp();

      void blockTillWaitForSyncComplete();

      virtual void beginFrame();

      virtual void beginRendering();

      virtual void endRendering();

      virtual void initViewports();

      void commitEyeTexture(unsigned int viewIndex, varjo_Viewport& viewPort, int layer, varjo_SwapChain* swapChain, varjo_SwapChain* depthSwapChain);

      void commitHudTexture(unsigned int viewIndex, varjo_Viewport viewPort, varjo_SwapChain* swapChain);

      virtual void updateEyeProjections();

      virtual void updateEyeProjections(unsigned int viewIndex, DtVirtualRealityChannel* vrChannel, unsigned int layer, bool updateVarjoViewOnly = false, bool isHudView = false);

      varjo_Viewport calculateFocusRect(varjo_Viewport contextViewport, const double focusProjectionMatrix[16], const double contextProjectionMatrix[16]);

#if VARJO_USE_GAZE == 1
      varjo_Error initGaze();
      
      bool getGazeNormalizedCoords(const osg::Matrixd& leftProjection, const osg::Matrixd& rightProjection,
                                                                       osg::Vec2* left, osg::Vec2* right) const;
#endif

   protected:

      varjo_Session* myVarjoSession;
      int32_t myViewCount;
      std::vector<varjo_Viewport> myViewports;
      std::vector<ViewSettings> myViewSettings;
      bool myUseDepthLayers;
      std::vector<varjo_LayerMultiProjView> myMultiprojectionViews;
      std::vector<varjo_ViewExtensionDepth> myExtDepthViews;
      std::vector<varjo_ViewExtensionDepthTestRange> myExtDepthTestRangeViews;
      std::vector<varjo_LayerMultiProjView> myHudViews;
      varjo_FrameInfo* myFrameInfo;
      std::string myDeviceName;

      bool myEyeTrackingInitalized;
      bool myHaveCalibratedEyeTracking;
      osg::Vec3d myHmdPostionOffset;
      osg::Quat myHmdRotationOffset;

      varjo_World* myVarjoWorld;
      std::unordered_map<int64_t, DtTrackedMarker> myTrackedMarkers;

      //std::thread* myWaitForSyncThread;
      DtVarjoWaitForSyncThread* myWaitForSyncThread;
   };
}