DtOculusChannel.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOculusChannelPlugin/vrvOculusChannelPlugin.h>
#include <vrvOculusChannelPlugin/oculusdevice.h>

#include <vrvOsg/DtOsgChannel.h>

#include <vrvUtil/DtQuat.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#include <OVR_CAPI.h>
#include <OVR_CAPI_GL.h>


#ifdef LEAP_SUPPORT
#include <Leap.h>
#endif

union ovrGLConfig; 

namespace makVrv 
{ 
   class DT_DLL_VRVOCULUSCHANNELPLUGIN DtOculusChannel : public DtOsgChannel
   {
   protected:
      friend class DtOculusChannelCreator;
      friend class DtOculusDrawable;
      friend class DtOculusSwapCallback;

      DtOculusChannel(DtDe& de, DtOsgWindow* window, 
         DtChannelConfiguration& config);

      virtual ~DtOculusChannel();



      virtual bool initialize();

      virtual void initializeOculusDevice(osg::RenderInfo& renderInfo);

      virtual void initializeOculusChannel();

      virtual void update();

      virtual void updateProjection();

      virtual void projectFor3D();

      virtual void setupCullVisitor(const osg::observer_ptr<osg::Camera>& camera);
     
      osg::Camera* createRTTCamera(int eye);

      virtual float getPixelsPerDisplayPixel();

      void blitMirrorTexture(osg::GraphicsContext *gc);

   public:      

      virtual void resetSensor();

      virtual void onPreTick();

      virtual void onPostTick();

      virtual void onShutdown();

      //virtual void warnOnOVRErrors();


      virtual void setMirroring(int view);
      virtual int mirroring();

      virtual std::vector<const osg::Camera*> getShadowableCameras() const; 

      virtual DtQuat hmdOrientation() {return DtQuat(myHmdOrientation.x(), myHmdOrientation.y(), myHmdOrientation.z(), myHmdOrientation.w()); }
      virtual DtVector hmdPosition() {return DtVector(myHmdPosition.x(), myHmdPosition.y(), myHmdPosition.z()); }

   protected:
      void updateEyes(double znear = 0.015, double zfar = 10000);

      ovrSession mySession;
      ovrHmdDesc myHmdDesc;
      ovrPosef myEyeRenderPose[2];  
      ovrEyeRenderDesc myEyeRenderDesc[2];
      ovrFovPort myEyeFov[2];
      ovrLayerEyeFov myLayer;

      osg::ref_ptr<OculusTextureBuffer> myTextureBuffer[2];
      osg::ref_ptr<OculusMirrorTexture> myMirrorTexture;

      bool myFrameStarted;

      int myMirroringView;
      bool myMonoscopic;

      osg::ref_ptr<osg::Camera> myRTTCameras[2];
      osg::ref_ptr<osg::Texture2D> myLeftDepthTexture;
      osg::ref_ptr<osg::Texture2D> myRightDepthTexture;

      osg::Quat myHmdOrientation;
      osg::Vec3d myHmdPosition;
      osg::Matrixf myLeftEyeProjectionMatrix;
      osg::Matrixf myRightEyeProjectionMatrix;
      osg::Matrixf myLeftEyeViewMatrix;
      osg::Matrixf myRightEyeViewMatrix;

      osg::ref_ptr<DtOculusDrawable> myOculusDrawable;
      osg::ref_ptr<osg::Group> myOculusDrawableGroup;
      bool myOculusInitialized;

      osg::ref_ptr<osg::Billboard> myHUDBillboard;
      osg::ref_ptr<osg::MatrixTransform> myHUDMatrixTransform;

      osg::ref_ptr<osg::GraphicsContext::SwapCallback> mySwapCallback;

      DtSignalConnectionManager myConnections;

#ifdef LEAP_SUPPORT
      Leap::Controller myLeapController;
      double myLastSimulationTime;
#endif
   };

   class DT_DLL_VRVOCULUSCHANNELPLUGIN DtOculusChannelCreator : public DtChannelCreator
   {
   public:
      virtual DtChannel* create(DtDe& de, DtWindow* window, DtChannelConfiguration& config);
   };

   class DT_DLL_VRVOCULUSCHANNELPLUGIN DtOculusDrawable : public osg::Drawable
   {
   public:
      DtOculusDrawable(DtOculusChannel* channel) : myOculusChannel(channel) {};

      virtual void drawImplementation(osg::RenderInfo& renderInfo) const 
      {
         DtOculusDrawable *mutableThis = const_cast< DtOculusDrawable *>(this);
         mutableThis->myOculusChannel->initializeOculusDevice(renderInfo);
      }

      virtual Object* cloneType() const {
         return new DtOculusDrawable(myOculusChannel);
      }
      virtual Object* clone(const osg::CopyOp& copyop) const {
         return new DtOculusDrawable(myOculusChannel);
      }
   protected:
      DtOculusChannel* myOculusChannel;
   };

   class DT_DLL_VRVOCULUSCHANNELPLUGIN DtOculusSwapCallback : public osg::GraphicsContext::SwapCallback
   {
   public:
      DtOculusSwapCallback(DtOculusChannel* channel) : myChannel(channel) {};
      void swapBuffersImplementation(osg::GraphicsContext *);

   protected:
      DtOculusChannel* myChannel;
   };
}