DtVirtualRealityDriver.h

Go to the documentation of this file.

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


#pragma once

#include "vrvVirtualReality/vrvVirtualReality.h"
#include "vrvVirtualReality/DtVirtualRealitySettingsRecord.h"

#include <vrvCore/DtDriver.h>
#include <vrvCore/DtDe.h>
#include <vrvCore/DtAgentManager.h>

#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtQuat.h>

#include <matrix/vlVector.h>

#include <osg/ref_ptr>
#include <osg/Texture2D>
#include <osg/Camera>

#include <boost/signal.hpp>

#include <list>

namespace vr
{
   class IVRSystem;
   struct TrackedDevicePose_t;
}

namespace osg
{
   class RenderInfo;
}

namespace makVrv
{
   class DtObserver;
   class DtOsgChannel;
   class DtWindow;
   class DtSubmitOverlayCallback;

   class DT_DLL_VRVVR DtVirtualRealityDriver : public DtDriver
   {
   private:
      DtVirtualRealityDriver();

      DtVirtualRealityDriver(const DtVirtualRealityDriver& orig);

      DtVirtualRealityDriver& operator=(const DtVirtualRealityDriver&);

   public:
      enum DtEye {Left, Right};

      DtVirtualRealityDriver(DtAgentManager& am);

      virtual ~DtVirtualRealityDriver();

      virtual const std::string& className() const;

      virtual bool onStart();

      virtual bool onStop();

      virtual bool onTick();

      static bool isVrAvailable();

      virtual void resetHmd();

      virtual void setMirroring(makArchives::DtVirtualRealitySettingsRecord::DtMirroring val);
      
      virtual makArchives::DtVirtualRealitySettingsRecord::DtMirroring mirroring() const;
      
      virtual void setMirrorChannel(std::string val);

      virtual osg::Texture2D* findMirrorTexture() const;

      virtual void setMirrorTexture(makArchives::DtVirtualRealitySettingsRecord::DtMirroring eye, osg::Texture2D* tex);
   
      virtual DtSubmitOverlayCallback* findOverlayCallback();

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

      virtual DtOsgChannel* findEyeChannel(DtEye whichEye);

      virtual DtObserver* findHmdObserver() const;

      virtual void setObserverForHmd(const std::string& obsName);

      virtual vr::IVRSystem* findVrSystem() const;
      
      boost::signal<void()> signal_postTick;

      boost::signal<void()> signal_reset;

   protected:
      virtual void createHmdWindow(DtDisplayConfiguration* prototypeConfig);

      virtual makVrv::DtOsgChannel* createEyeChannel(int eye, DtDisplayConfiguration* prototypeConfig);

      virtual void initializeOverlay(DtOsgChannel* channel);

      virtual void uninstallOverlay(DtOsgChannel* channel);

      void installResetKeyMap();

      virtual void handleEnabledChanged(bool val);

      virtual void handleObserverLost(DtObserver* obs);

      virtual void updateMirroring(makArchives::DtVirtualRealitySettingsRecord::DtMirroring mirrorType, std::string channelName);

      virtual bool getPose(osg::Vec3d& position, osg::Quat& orienation, int index) const;

      virtual void updatePoseInformation();

      DtDe& myDe;

      //OpenVR Structs
      vr::IVRSystem* myVrSystem;
      vr::TrackedDevicePose_t* myTrackedPoses;

      //HMD observer, offscreen window and eye channels
      DtObserver* myHmdObserver;
      DtOsgChannel* myLeftEyeChannel;
      DtOsgChannel* myRightEyeChannel;
      DtWindow* myHmdWindow;

      //main 2d overlay
      osg::ref_ptr<osg::Texture2D> myOverlayTexture;
      osg::ref_ptr<osg::Texture2D> myOverlayDepthTexture;
      osg::ref_ptr<DtSubmitOverlayCallback> myOverlaySubmitCallback;

      //mirroring structs
      makArchives::DtVirtualRealitySettingsRecord::DtMirroring myMirroring;
      std::string myMirrorChannelName;
      DtOsgChannel* myMirrorChannel;
      osg::ref_ptr<osg::Texture2D> myMirrorTexture;
      std::string myMirrorObserverRestore;

      DtSignalConnectionManager myConnections;      
   };

}