vtkVRRenderWindow.h

Go to the documentation of this file.

/*=========================================================================
 
Program:   Visualization Toolkit
Module:    vtkVRRenderWindow.h
 
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 vtkVRRenderWindow_h
#define vtkVRRenderWindow_h
 
#include "vtkEventData.h"    // for enums
#include "vtkOpenGLHelper.h" // used for ivars
#include "vtkOpenGLRenderWindow.h"
#include "vtkRenderingVRModule.h" // For export macro
#include "vtk_glew.h"             // used for methods
 
#include <vector> // ivars
 
class vtkCamera;
class vtkMatrix4x4;
class vtkVRModel;
class vtkOpenGLVertexBufferObject;
class vtkTransform;
 
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* GetTrackedDeviceModel(vtkEventDataDevice idx)
  {
    return this->GetTrackedDeviceModel(idx, 0);
  }
  vtkVRModel* GetTrackedDeviceModel(uint32_t idx) { return this->TrackedDeviceToRenderModel[idx]; }
  virtual vtkVRModel* GetTrackedDeviceModel(vtkEventDataDevice idx, uint32_t index) = 0;
 
  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);
 
  virtual void AddRenderer(vtkRenderer*) override;
 
  virtual void Start() override;
 
  virtual void Initialize() override;
 
  virtual void Finalize() override;
 
  void MakeCurrent() override;
 
  void ReleaseCurrent() override;
 
  virtual bool IsCurrent() override;
 
  const char* ReportCapabilities() override { return "VR System"; }
 
  vtkTypeBool IsDirect() override { return 1; }
 
  virtual vtkTypeBool GetEventPending() override { return 0; }
 
  virtual int* GetScreenSize() override;
 
 
  void SetSize(int width, int height) override;
  void SetSize(int a[2]) override { this->SetSize(a[0], a[1]); }
 
  // implement required virtual functions
  virtual void* GetGenericDisplayId() override
  {
    return (void*)this->HelperWindow->GetGenericDisplayId();
  }
  virtual void* GetGenericWindowId() override
  {
    return (void*)this->HelperWindow->GetGenericWindowId();
  }
  virtual void* GetGenericParentId() override { return (void*)nullptr; }
  virtual void* GetGenericContext() override
  {
    return (void*)this->HelperWindow->GetGenericContext();
  }
  virtual void* GetGenericDrawable() override
  {
    return (void*)this->HelperWindow->GetGenericDrawable();
  }
 
  virtual int SupportsOpenGL() override { return 1; }
 
  virtual void Render() override;
 
  vtkGetObjectMacro(HelperWindow, vtkOpenGLRenderWindow);
  void SetHelperWindow(vtkOpenGLRenderWindow* val);
 
  // Get the state object used to keep track of
  // OpenGL state
  vtkOpenGLState* GetState() override;
 
  void ReleaseGraphicsResources(vtkWindow*) override;
 
  virtual void RenderModels() = 0;
 
  virtual bool GetPoseMatrixWorldFromDevice(
    vtkEventDataDevice device, vtkMatrix4x4* poseMatrixWorld) = 0;
 
 
  vtkSetMacro(TrackHMD, bool);
  vtkGetMacro(TrackHMD, bool);
 
  virtual void UpdateHMDMatrixPose(){};
 
protected:
  vtkVRRenderWindow();
  ~vtkVRRenderWindow() override;
 
  virtual void CreateAWindow() override {}
  virtual void DestroyWindow() override {}
 
  virtual bool GetSizeFromAPI() = 0;
 
  virtual std::string GetWindowTitleFromAPI() { return "VTK - VR"; }
 
  struct FramebufferDesc
  {
    GLuint ResolveFramebufferId = 0;
    GLuint ResolveColorTextureId = 0;
    GLuint ResolveDepthTextureId = 0;
  };
 
  // One per view (typically one per eye)
  std::vector<FramebufferDesc> FramebufferDescs;
 
  virtual bool CreateFramebuffers() = 0;
 
  void RenderFramebuffer(FramebufferDesc& framebufferDesc);
 
  bool TrackHMD;
 
  std::vector<vtkVRModel*> VTKRenderModels;
  // This vector must be resized in subclass with the maximum number of devices
  std::vector<vtkVRModel*> TrackedDeviceToRenderModel;
 
  // used in computing the pose
  vtkTransform* HMDTransform;
  double PhysicalViewDirection[3];
  double PhysicalViewUp[3];
  double PhysicalTranslation[3];
  double PhysicalScale;
 
  vtkOpenGLRenderWindow* HelperWindow;
 
private:
  vtkVRRenderWindow(const vtkVRRenderWindow&) = delete;
  void operator=(const vtkVRRenderWindow&) = delete;
};
 
#endif