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 "vtkVRRenderWindow.h"
 
#include "vtkEventData.h"    // for enums
#include "vtkOpenGLHelper.h" // used for ivars
#include "vtk_glew.h"        // used for methods
#include <openvr.h>          // for ivars
#include <vector>            // ivars
 
class vtkCamera;
class vtkMatrix4x4;
class vtkOpenVRModel;
class vtkOpenVROverlay;
class vtkOpenGLVertexBufferObject;
class vtkTransform;
 
class VTKRENDERINGOPENVR_EXPORT vtkOpenVRRenderWindow : public vtkVRRenderWindow
{
public:
  static vtkOpenVRRenderWindow* New();
  vtkTypeMacro(vtkOpenVRRenderWindow, vtkVRRenderWindow);
 
  void Initialize(void) override;
 
  void ReleaseGraphicsResources(vtkWindow* renWin) override;
 
  vr::IVRSystem* GetHMD() { return this->HMD; }
 
  static bool IsHMDPresent();
 
  vtkRenderWindowInteractor* MakeRenderWindowInteractor() override;
 
  void Render() override;
 
  void StereoMidpoint() override;
 
  void StereoRenderComplete() override;
 
  void RenderOverlay();
 
  /*
   * Set/Get the overlay to use on the VR dashboard
   */
  vtkGetObjectMacro(DashboardOverlay, vtkOpenVROverlay);
  void SetDashboardOverlay(vtkOpenVROverlay*);
 
 
  vtkGetMacro(BaseStationVisibility, bool);
  vtkSetMacro(BaseStationVisibility, bool);
  vtkBooleanMacro(BaseStationVisibility, bool);
 
  void UpdateHMDMatrixPose() override;
 
  using vtkVRRenderWindow::GetTrackedDeviceModel;
 
  vtkVRModel* GetTrackedDeviceModel(vtkEventDataDevice idx, uint32_t index) override;
 
  vr::IVRRenderModels* GetOpenVRRenderModels() { return this->OpenVRRenderModels; }
 
  vtkEventDataDevice GetDeviceFromDeviceIndex(vr::TrackedDeviceIndex_t index);
 
  vr::TrackedDeviceIndex_t GetTrackedDeviceIndexForDevice(vtkEventDataDevice dev)
  {
    return this->GetTrackedDeviceIndexForDevice(dev, 0);
  }
  vr::TrackedDeviceIndex_t GetTrackedDeviceIndexForDevice(vtkEventDataDevice dev, uint32_t index);
  uint32_t GetNumberOfTrackedDevicesForDevice(vtkEventDataDevice dev);
 
  vr::TrackedDevicePose_t* GetTrackedDevicePose(vtkEventDataDevice idx)
  {
    return this->GetTrackedDevicePose(idx, 0);
  }
  vr::TrackedDevicePose_t* GetTrackedDevicePose(vtkEventDataDevice idx, uint32_t index);
  vr::TrackedDevicePose_t& GetTrackedDevicePose(vr::TrackedDeviceIndex_t idx)
  {
    return this->TrackedDevicePose[idx];
  }
 
  void RenderModels() override;
 
  bool GetPoseMatrixWorldFromDevice(
    vtkEventDataDevice device, vtkMatrix4x4* poseMatrixWorld) override;
 
  void ConvertOpenVRPoseToMatrices(const vr::TrackedDevicePose_t& tdPose,
    vtkMatrix4x4* poseMatrixWorld, vtkMatrix4x4* poseMatrixPhysical = nullptr);
 
protected:
  vtkOpenVRRenderWindow();
  ~vtkOpenVRRenderWindow() override;
 
  std::string GetWindowTitleFromAPI() override;
 
  bool GetSizeFromAPI() override;
 
  bool BaseStationVisibility;
 
  vr::IVRSystem* HMD;
  vr::IVRRenderModels* OpenVRRenderModels;
 
  bool CreateFramebuffers() override;
 
  bool CreateOneFramebuffer(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);
 
  vr::TrackedDevicePose_t TrackedDevicePose[vr::k_unMaxTrackedDeviceCount];
 
  vtkOpenVROverlay* DashboardOverlay;
 
private:
  vtkOpenVRRenderWindow(const vtkOpenVRRenderWindow&) = delete;
  void operator=(const vtkOpenVRRenderWindow&) = delete;
};
 
#endif