vtkOpenVRRenderWindow.h

Go to the documentation of this file.

/*=========================================================================

Program:   Visualization Toolkit

Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#ifndef vtkOpenVRRenderWindow_h
#define vtkOpenVRRenderWindow_h

#include "vtkRenderingOpenVRModule.h" // For export macro
#include "vtkOpenGLRenderWindow.h"

#include <openvr.h> // for ivars
#include <vector> // ivars
#include "vtkOpenGLHelper.h" // used for ivars
#include "vtk_glew.h" // used for methods
#include "vtkEventData.h" // for enums

class vtkCamera;
class vtkMatrix4x4;
class vtkOpenVRModel;
class vtkOpenVROverlay;
class vtkOpenGLVertexBufferObject;
class vtkTransform;

class VTKRENDERINGOPENVR_EXPORT vtkOpenVRRenderWindow : public vtkOpenGLRenderWindow
{
public:
  enum
    {
    PhysicalToWorldMatrixModified = vtkCommand::UserEvent + 200
    };

  static vtkOpenVRRenderWindow *New();
  vtkTypeMacro(vtkOpenVRRenderWindow,vtkOpenGLRenderWindow);
  void PrintSelf(ostream& os, vtkIndent indent);

  vr::IVRSystem *GetHMD() { return this->HMD; };

  void RenderOverlay();


  vtkGetObjectMacro(DashboardOverlay, vtkOpenVROverlay);
  void SetDashboardOverlay(vtkOpenVROverlay *);

  void UpdateHMDMatrixPose();


  GLuint GetLeftRenderBufferId()
    { return this->LeftEyeDesc.m_nRenderFramebufferId; };
  GLuint GetLeftResolveBufferId()
    { return this->LeftEyeDesc.m_nResolveFramebufferId; };
  GLuint GetRightRenderBufferId()
    { return this->RightEyeDesc.m_nRenderFramebufferId; };
  GLuint GetRightResolveBufferId()
    { return this->RightEyeDesc.m_nResolveFramebufferId; };
  void GetRenderBufferSize(int &width, int &height)
    {
    width = this->Size[0];
    height = this->Size[1];
    };

  vtkOpenVRModel *GetTrackedDeviceModel(vtkEventDataDevice idx);
  vtkOpenVRModel *GetTrackedDeviceModel(vr::TrackedDeviceIndex_t idx) {
    return this->TrackedDeviceToRenderModel[idx]; };

  vr::IVRRenderModels * GetOpenVRRenderModels() {
    return this->OpenVRRenderModels; };

  vr::TrackedDeviceIndex_t GetTrackedDeviceIndexForDevice(vtkEventDataDevice dev);

  void GetTrackedDevicePose(vtkEventDataDevice idx, vr::TrackedDevicePose_t **pose);
  vr::TrackedDevicePose_t &GetTrackedDevicePose(vr::TrackedDeviceIndex_t idx) {
    return this->TrackedDevicePose[idx]; };

  void InitializeViewFromCamera(vtkCamera *cam);


  virtual void SetPhysicalViewDirection(double,double,double);
  virtual void SetPhysicalViewDirection(double[3]);
  vtkGetVector3Macro(PhysicalViewDirection, double);


  virtual void SetPhysicalViewUp(double,double,double);
  virtual void SetPhysicalViewUp(double[3]);
  vtkGetVector3Macro(PhysicalViewUp, double);


  virtual void SetPhysicalTranslation(double,double,double);
  virtual void SetPhysicalTranslation(double[3]);
  vtkGetVector3Macro(PhysicalTranslation, double);


  virtual void SetPhysicalScale(double);
  vtkGetMacro(PhysicalScale, double);

  void SetPhysicalToWorldMatrix(vtkMatrix4x4* matrix);
  void GetPhysicalToWorldMatrix(vtkMatrix4x4* matrix);


  vtkSetMacro(TrackHMD, bool);
  vtkGetMacro(TrackHMD, bool);

  virtual void AddRenderer(vtkRenderer *) override;

  virtual void Start(void);

  virtual void StereoUpdate();

  virtual void StereoMidpoint();

  virtual void StereoRenderComplete();

  void Frame(void);

  virtual void Initialize(void);

  virtual void Finalize(void);

  void MakeCurrent();

  virtual bool IsCurrent();

  const char *ReportCapabilities() { return "OpenVR System";};

  int IsDirect() { return 1; };

  virtual  int GetEventPending() { return 0;};

  virtual int *GetScreenSize();


  virtual void SetSize(int,int);
  virtual void SetSize(int a[2]) {vtkOpenGLRenderWindow::SetSize(a);};


  virtual void SetPosition(int,int);
  virtual void SetPosition(int a[2]) {vtkOpenGLRenderWindow::SetPosition(a);};

  // implement required virtual functions
  void SetWindowInfo(const char *) {};
  void SetNextWindowInfo(const char *) {};
  void SetParentInfo(const char *) {};
  virtual void *GetGenericDisplayId() {return (void *)this->HelperWindow->GetGenericDisplayId();};
  virtual void *GetGenericWindowId()  {return (void *)this->HelperWindow->GetGenericWindowId();};
  virtual void *GetGenericParentId()  {return (void *)nullptr;};
  virtual void *GetGenericContext() { return (void *)this->HelperWindow->GetGenericContext(); };
  virtual void *GetGenericDrawable()  {return (void *)this->HelperWindow->GetGenericDrawable();};
  virtual void SetDisplayId(void *) {};
  void  SetWindowId(void *) {};
  void  SetParentId(void *) {};
  void HideCursor() {};
  void ShowCursor() {};
  virtual void SetFullScreen(vtkTypeBool) {};
  virtual void WindowRemap(void) {};
  virtual void SetNextWindowId(void *) {};

  virtual int SupportsOpenGL() { return 1; };

  void Render();

  vtkGetObjectMacro(HelperWindow, vtkOpenGLRenderWindow);
  void SetHelperWindow(vtkOpenGLRenderWindow *val);

  // Get the state object used to keep track of
  // OpenGL state
  vtkOpenGLState *GetState() override;

protected:
  vtkOpenVRRenderWindow();
  ~vtkOpenVRRenderWindow();

  virtual void ReleaseGraphicsResources(vtkRenderWindow *);

  virtual void CreateAWindow() {};
  virtual void DestroyWindow() {};

  std::string m_strDriver;
  std::string m_strDisplay;
  vr::IVRSystem *HMD;
  vr::IVRRenderModels *OpenVRRenderModels;

  struct FramebufferDesc
  {
    GLuint m_nDepthBufferId;
    GLuint m_nRenderTextureId;
    GLuint m_nRenderFramebufferId;
    GLuint m_nResolveTextureId;
    GLuint m_nResolveFramebufferId;
  };
  FramebufferDesc LeftEyeDesc;
  FramebufferDesc RightEyeDesc;
  bool CreateFrameBuffer( int nWidth, int nHeight,
    FramebufferDesc &framebufferDesc );

  // convert a device index to a human string
  std::string GetTrackedDeviceString(
    vr::IVRSystem *pHmd,
    vr::TrackedDeviceIndex_t unDevice,
    vr::TrackedDeviceProperty prop,
    vr::TrackedPropertyError *peError = nullptr );

  // devices may have polygonal models
  // load them
  vtkOpenVRModel *FindOrLoadRenderModel(const char *modelName );
  void RenderModels();
  std::vector<vtkOpenVRModel * > VTKRenderModels;
  vtkOpenVRModel *TrackedDeviceToRenderModel[ vr::k_unMaxTrackedDeviceCount ];
  vr::TrackedDevicePose_t TrackedDevicePose[ vr::k_unMaxTrackedDeviceCount ];

  // used in computing the pose
  vtkTransform *HMDTransform;
  double PhysicalViewDirection[3];
  double PhysicalViewUp[3];
  double PhysicalTranslation[3];
  double PhysicalScale;

  // for the overlay
  vtkOpenVROverlay *DashboardOverlay;

  bool TrackHMD;

  vtkOpenGLRenderWindow *HelperWindow;


private:
  vtkOpenVRRenderWindow(const vtkOpenVRRenderWindow&) = delete;
  void operator=(const vtkOpenVRRenderWindow&) = delete;
};


#endif