DtVirtualRealityDriver.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2024 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 <vrvUtil/signalslib.h>

#include <list>


namespace osg
{
   class RenderInfo;
}

namespace makVrv
{
   class DtChannel;
   class DtWindow;
   class DtObserver;
   class DtOsgChannel;
   class DtOsgWindow;
   class DtChannelManager;
   class DtInputDriver;
   class DtSubmitOverlayCallback;
   class DtVirtualRealityProvider;
   class DtVirtualRealityChannel;
   class DtSwapChainPreviewDrawable;

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

      DtVirtualRealityDriver(const DtVirtualRealityDriver& orig);

      DtVirtualRealityDriver& operator=(const DtVirtualRealityDriver&);

   public:
      DtVirtualRealityDriver(DtAgentManager& am);

      virtual ~DtVirtualRealityDriver();

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

      virtual bool onStart();

      virtual bool onStop();

      virtual bool onTick();

      virtual bool isVrAvailable();

      virtual vrvVirtualReality::DtVrRenderMode renderMode() const;

      virtual void resetHmd();

      virtual void triggerAction1();

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

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

      virtual DtVirtualRealityChannel* findEyeChannel(vrvVirtualReality::DtEye whichEye);

      virtual DtOsgChannel* findMirrorChannel();

      virtual DtSwapChainPreviewDrawable* findPreviewDrawable();

      virtual DtObserver* findHmdObserver() const;

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

      void handleEnableMixedRealityChanged(bool val);

      void handleEnableRealWorldDepthTestingChanged(bool val);

      virtual void setProvider(DtVirtualRealityProvider* provider);

      virtual DtVirtualRealityProvider* findProvider() const;

      virtual osg::Texture* findOverlayTexture() const;

      virtual DtOsgChannel* findOverlayChannel();

      virtual osg::StateSet* findOverlayQuadStateSet() const;

      virtual void initializeOverlay(DtOsgChannel* channel);

      virtual void useOverlayRenderTextures(osg::Camera* camera, bool clearDepth);

      virtual void installMixedRealityMaskingObject(osg::Group* mountTo, osg::Vec3 offset, 
         bool followObserver, const std::string& modelFileOrShapeName);

      virtual void uninstallMixedRealityMaskingObject();

      virtual void startMasking();

      virtual void stopMasking();

      virtual void setOrientationSmoothingEnabled(bool enabled);

      virtual void setOrientationSmoothingParams(double alpha, double threshold);

      boost::signalslib::signal<void()> signal_tick;

      boost::signalslib::signal<void()> signal_reset;

      boost::signalslib::signal<void(bool)> signal_vrRunningChaned;

      boost::signalslib::signal<void()> signal_vrResolutionChanged;

      boost::signalslib::signal<void()> signal_vrOverlayChanged;

   protected:
      virtual DtOsgWindow* findHmdWindow();

      virtual DtVirtualRealityChannel* createEyeChannel(vrvVirtualReality::DtEye eye, DtDisplayConfiguration* prototypeConfig);

      virtual void installMultiViewShadersForChannel(DtVirtualRealityChannel* vrChannel);

      virtual void uninstallOverlay(DtOsgChannel* channel);

      virtual void handleOverlayDimensionsChanged(float val);

      virtual void handleResolutionScaleChanged(int scale);

      virtual void handleEnableVRSChanged(bool enable);

      virtual void handleDisableAAChanged(bool disable);

      void installResetKeyMap();

      void installAction1KeyMap();

      virtual void handleEnabledChanged(bool val);

      virtual void handleObserverLost(DtInputDriver*, DtObserver* observer);

      virtual void enableDesktopMirroring(bool enable);

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

      virtual bool getPose(DtVector& position, DtQuat& orienation, int index) const;

      virtual void connectSignals();

      virtual void onPretick();

      virtual void onUpdate(double simTime);

      virtual void onPostUpdate();

      virtual void onPostTick();

      virtual void updatePoseInformation();

      void slot_hdrEnabledChanged(bool enabled);

      void slot_channelDestroyed(DtChannelManager* channelManager, DtChannel* channel);

      void slot_windowToBeDestroyed(DtWindow* window);

   protected:
      DtDe& myDe;
      DtVirtualRealityProvider* myVrProvider;

      //HMD observer, offscreen window and eye channels
      DtObserver* myHmdObserver;
      DtOsgWindow* myHmdWindow;
      DtWindowConfiguration myHmdWindowConfig;

      typedef std::map<vrvVirtualReality::DtEye, DtVirtualRealityChannel*> DtVrEyeToChannelMap;
      DtVrEyeToChannelMap myChannels;

      vrvVirtualReality::DtVrRenderMode myRenderMode;

      bool myUseMixedRealityMask;

      //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;
      DtWindow* myMirrorWindow;
      std::string myMirrorObserverRestore;
      int myMirrorChannelRenderOrderRestore;
      osg::ref_ptr<DtSwapChainPreviewDrawable> myPreviewDrawable;

      DtVirtualRealityChannel* myStereoOverlayChannel;
      osg::ref_ptr<osg::MatrixTransform> myOverlayQuad;

      // orientation smoothing
      bool myOriSmoothingEnabled;
      double myOriFilterAlpha; //Value should be between 0.01f and 0.99f. Smaller value is more damping.
      double myOriFilterThreshold;
      bool myOriSmoothingInit;
      osg::Quat mySmoothedOri;
      osg::Quat myLastHmdOri;
      double myLastTime;

      DtSignalConnectionManager myConnections;
   };

}