vtkVRRenderWindow.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkVRRenderWindow_h
#define vtkVRRenderWindow_h
 
#include "vtkEventData.h" // for enums
#include "vtkNew.h"       // for vtkNew
#include "vtkOpenGLRenderWindow.h"
#include "vtkRenderingVRModule.h" // For export macro
#include "vtkSmartPointer.h"      // for vtkSmartPointer
#include "vtk_glew.h"             // used for methods
 
#include <vector> // ivars
 
VTK_ABI_NAMESPACE_BEGIN
class vtkCamera;
class vtkMatrix4x4;
class vtkVRModel;
 
class VTKRENDERINGVR_EXPORT vtkVRRenderWindow : public vtkOpenGLRenderWindow
{
public:
  enum
  {
    PhysicalToWorldMatrixModified = vtkCommand::UserEvent + 200
  };
 
  enum
  {
    LeftEye = 0,
    RightEye
  };
 
  vtkTypeMacro(vtkVRRenderWindow, vtkOpenGLRenderWindow);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  vtkRenderWindowInteractor* MakeRenderWindowInteractor() override = 0;
 
 
  GLuint GetLeftResolveBufferId() { return this->FramebufferDescs[LeftEye].ResolveFramebufferId; }
  GLuint GetRightResolveBufferId() { return this->FramebufferDescs[RightEye].ResolveFramebufferId; }
  void GetRenderBufferSize(int& width, int& height)
  {
    width = this->Size[0];
    height = this->Size[1];
  }
 
 
  vtkVRModel* GetModelForDevice(vtkEventDataDevice idx);
  vtkVRModel* GetModelForDeviceHandle(uint32_t handle);
 
 
  void SetModelForDeviceHandle(uint32_t handle, vtkVRModel* model);
 
 
  vtkMatrix4x4* GetDeviceToPhysicalMatrixForDevice(vtkEventDataDevice idx);
  vtkMatrix4x4* GetDeviceToPhysicalMatrixForDeviceHandle(uint32_t handle);
 
  /*
   * This method gets a device handle for a given device. index is used to
   * disambiguate when there are multiple device handles that map to a
   * device.
   */
  uint32_t GetDeviceHandleForDevice(vtkEventDataDevice dev, uint32_t index = 0);
 
  /*
   * This method returns how many device handles map to a device.
   */
  uint32_t GetNumberOfDeviceHandlesForDevice(vtkEventDataDevice dev);
 
  /*
   * This method adds a device handle if not already present. The second
   * signature also sets the device associated with the device handle.
   */
  void AddDeviceHandle(uint32_t handle);
  void AddDeviceHandle(uint32_t handle, vtkEventDataDevice device);
 
  /*
   * This method gets a device for a given device handle.
   */
  vtkEventDataDevice GetDeviceForDeviceHandle(uint32_t handle);
 
  bool GetDeviceToWorldMatrixForDevice(
    vtkEventDataDevice device, vtkMatrix4x4* deviceToWorldMatrix) override;
  virtual bool GetDeviceToWorldMatrixForDeviceHandle(
    uint32_t handle, vtkMatrix4x4* deviceToWorldMatrix);
 
  virtual 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) override;
 
  void AddRenderer(vtkRenderer*) override;
 
  void MakeCurrent() override;
 
  void ReleaseCurrent() override;
 
  bool IsCurrent() override;
 
  const char* ReportCapabilities() override { return "VR System"; }
 
  vtkTypeBool IsDirect() override { return 1; }
 
  vtkTypeBool GetEventPending() override { return 0; }
 
  int* GetScreenSize() override;
 
 
  void SetSize(int width, int height) override;
  void SetSize(int a[2]) override { this->SetSize(a[0], a[1]); }
 
 
  void* GetGenericDisplayId() override { return this->HelperWindow->GetGenericDisplayId(); }
  void* GetGenericWindowId() override { return this->HelperWindow->GetGenericWindowId(); }
  void* GetGenericParentId() override { return nullptr; }
  void* GetGenericContext() override { return this->HelperWindow->GetGenericContext(); }
  void* GetGenericDrawable() override { return this->HelperWindow->GetGenericDrawable(); }
 
  int SupportsOpenGL() override { return 1; }
 
  void Render() override;
 
 
  vtkGetObjectMacro(HelperWindow, vtkOpenGLRenderWindow);
  void SetHelperWindow(vtkOpenGLRenderWindow* val);
 
  vtkOpenGLState* GetState() override;
 
  void ReleaseGraphicsResources(vtkWindow*) override;
 
  virtual void RenderModels() = 0;
 
 
  vtkSetMacro(TrackHMD, bool);
  vtkGetMacro(TrackHMD, bool);
 
 
  vtkGetMacro(BaseStationVisibility, bool);
  vtkSetMacro(BaseStationVisibility, bool);
  vtkBooleanMacro(BaseStationVisibility, bool);
 
  virtual void UpdateHMDMatrixPose(){};
 
  vtkGetMacro(VRInitialized, bool);
 
protected:
  vtkVRRenderWindow();
  ~vtkVRRenderWindow() override;
 
  struct FramebufferDesc
  {
    GLuint ResolveFramebufferId = 0;
    GLuint ResolveColorTextureId = 0;
    GLuint ResolveDepthTextureId = 0;
  };
 
  void CreateAWindow() override {}
  void DestroyWindow() override {}
 
  virtual bool GetSizeFromAPI() = 0;
 
  virtual std::string GetWindowTitleFromAPI() { return "VTK - VR"; }
 
  virtual bool CreateFramebuffers(uint32_t viewCount = 2) = 0;
  virtual void RenderFramebuffer(FramebufferDesc& framebufferDesc) = 0;
 
  bool VRInitialized = false;
  bool TrackHMD = true;
 
  // One per view (typically one per eye)
  std::vector<FramebufferDesc> FramebufferDescs;
 
  class DeviceData
  {
  public:
    vtkSmartPointer<vtkVRModel> Model;
    vtkNew<vtkMatrix4x4> DeviceToPhysicalMatrix;
    vtkEventDataDevice Device = vtkEventDataDevice::Unknown;
    uint32_t Index = 0;
  };
 
  std::map<uint32_t, DeviceData> DeviceHandleToDeviceDataMap;
  uint32_t InvalidDeviceIndex = UINT32_MAX;
 
  // -Z axis of the Physical to World matrix
  double PhysicalViewDirection[3] = { 0.0, 0.0, -1.0 };
  // Y axis of the Physical to World matrix
  double PhysicalViewUp[3] = { 0.0, 1.0, 0.0 };
  // Inverse of the translation component of the Physical to World matrix, in mm
  double PhysicalTranslation[3] = { 0.0, 0.0, 0.0 };
  // Scale of the Physical to World matrix
  double PhysicalScale = 1.0;
 
  bool BaseStationVisibility = false;
 
  vtkOpenGLRenderWindow* HelperWindow;
 
private:
  vtkVRRenderWindow(const vtkVRRenderWindow&) = delete;
  void operator=(const vtkVRRenderWindow&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif