VTK  9.2.6
vtkVRRenderWindow.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3 Program: Visualization Toolkit
4 Module: vtkVRRenderWindow.h
5 
6 Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7 All rights reserved.
8 See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10 This software is distributed WITHOUT ANY WARRANTY; without even
11 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12 PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
51 #ifndef vtkVRRenderWindow_h
52 #define vtkVRRenderWindow_h
53 
54 #include "vtkEventData.h" // for enums
55 #include "vtkNew.h" // for vtkNew
56 #include "vtkOpenGLRenderWindow.h"
57 #include "vtkRenderingVRModule.h" // For export macro
58 #include "vtkSmartPointer.h" // for vtkSmartPointer
59 #include "vtk_glew.h" // used for methods
60 
61 #include <vector> // ivars
62 
63 class vtkCamera;
64 class vtkMatrix4x4;
65 class vtkVRModel;
66 
67 class VTKRENDERINGVR_EXPORT vtkVRRenderWindow : public vtkOpenGLRenderWindow
68 {
69 public:
70  enum
71  {
72  PhysicalToWorldMatrixModified = vtkCommand::UserEvent + 200
73  };
74 
75  enum
76  {
77  LeftEye = 0,
78  RightEye
79  };
80 
82  void PrintSelf(ostream& os, vtkIndent indent) override;
83 
89 
91 
94  GLuint GetLeftResolveBufferId() { return this->FramebufferDescs[LeftEye].ResolveFramebufferId; }
95  GLuint GetRightResolveBufferId() { return this->FramebufferDescs[RightEye].ResolveFramebufferId; }
96  void GetRenderBufferSize(int& width, int& height)
97  {
98  width = this->Size[0];
99  height = this->Size[1];
100  }
102 
104 
107  vtkVRModel* GetModelForDevice(vtkEventDataDevice idx);
108  vtkVRModel* GetModelForDeviceHandle(uint32_t handle);
110 
112 
115  void SetModelForDeviceHandle(uint32_t handle, vtkVRModel* model);
117 
119 
124  vtkMatrix4x4* GetDeviceToPhysicalMatrixForDevice(vtkEventDataDevice idx);
125  vtkMatrix4x4* GetDeviceToPhysicalMatrixForDeviceHandle(uint32_t handle);
127 
129  /*
130  * This method gets a device handle for a given device. index is used to
131  * disambiguate when there are multiple device handles that map to a
132  * device.
133  */
134  uint32_t GetDeviceHandleForDevice(vtkEventDataDevice dev, uint32_t index = 0);
136 
138  /*
139  * This method returns how many device handles map to a device.
140  */
141  uint32_t GetNumberOfDeviceHandlesForDevice(vtkEventDataDevice dev);
143 
145  /*
146  * This method adds a device handle if not already present. The second
147  * signature also sets the device associated with the device handle.
148  */
149  void AddDeviceHandle(uint32_t handle);
150  void AddDeviceHandle(uint32_t handle, vtkEventDataDevice device);
152 
154  /*
155  * This method gets a device for a given device handle.
156  */
157  vtkEventDataDevice GetDeviceForDeviceHandle(uint32_t handle);
159 
167  vtkEventDataDevice device, vtkMatrix4x4* deviceToWorldMatrix) override;
168  virtual bool GetDeviceToWorldMatrixForDeviceHandle(
169  uint32_t handle, vtkMatrix4x4* deviceToWorldMatrix);
170 
178  virtual void InitializeViewFromCamera(vtkCamera* cam);
179 
181 
189  virtual void SetPhysicalViewDirection(double, double, double);
190  virtual void SetPhysicalViewDirection(double[3]);
191  vtkGetVector3Macro(PhysicalViewDirection, double);
193 
195 
203  virtual void SetPhysicalViewUp(double, double, double);
204  virtual void SetPhysicalViewUp(double[3]);
205  vtkGetVector3Macro(PhysicalViewUp, double);
207 
209 
217  virtual void SetPhysicalTranslation(double, double, double);
218  virtual void SetPhysicalTranslation(double[3]);
219  vtkGetVector3Macro(PhysicalTranslation, double);
221 
223 
232  virtual void SetPhysicalScale(double);
233  vtkGetMacro(PhysicalScale, double);
235 
241  void SetPhysicalToWorldMatrix(vtkMatrix4x4* matrix);
242 
247  void GetPhysicalToWorldMatrix(vtkMatrix4x4* matrix) override;
248 
252  void AddRenderer(vtkRenderer*) override;
253 
257  void Start() override;
258 
262  void Initialize() override;
263 
269  void Finalize() override;
270 
274  void MakeCurrent() override;
275 
279  void ReleaseCurrent() override;
280 
284  bool IsCurrent() override;
285 
289  const char* ReportCapabilities() override { return "VR System"; }
290 
294  vtkTypeBool IsDirect() override { return 1; }
295 
301  vtkTypeBool GetEventPending() override { return 0; }
302 
306  int* GetScreenSize() override;
307 
309 
316  void SetSize(int width, int height) override;
317  void SetSize(int a[2]) override { this->SetSize(a[0], a[1]); }
319 
321 
324  void* GetGenericDisplayId() override { return (void*)this->HelperWindow->GetGenericDisplayId(); }
325  void* GetGenericWindowId() override { return (void*)this->HelperWindow->GetGenericWindowId(); }
326  void* GetGenericParentId() override { return (void*)nullptr; }
327  void* GetGenericContext() override { return (void*)this->HelperWindow->GetGenericContext(); }
328  void* GetGenericDrawable() override { return (void*)this->HelperWindow->GetGenericDrawable(); }
330 
334  int SupportsOpenGL() override { return 1; }
335 
340  void Render() override;
341 
343 
346  vtkGetObjectMacro(HelperWindow, vtkOpenGLRenderWindow);
347  void SetHelperWindow(vtkOpenGLRenderWindow* val);
349 
353  vtkOpenGLState* GetState() override;
354 
359  void ReleaseGraphicsResources(vtkWindow*) override;
360 
364  virtual void RenderModels() = 0;
365 
367 
371  vtkSetMacro(TrackHMD, bool);
372  vtkGetMacro(TrackHMD, bool);
374 
376 
379  vtkGetMacro(BaseStationVisibility, bool);
380  vtkSetMacro(BaseStationVisibility, bool);
381  vtkBooleanMacro(BaseStationVisibility, bool);
383 
387  virtual void UpdateHMDMatrixPose(){};
388 
392  vtkGetMacro(Initialized, bool);
393 
394 protected:
396  ~vtkVRRenderWindow() override;
397 
399  {
400  GLuint ResolveFramebufferId = 0;
401  GLuint ResolveColorTextureId = 0;
402  GLuint ResolveDepthTextureId = 0;
403  };
404 
405  void CreateAWindow() override {}
406  void DestroyWindow() override {}
407 
413  virtual bool GetSizeFromAPI() = 0;
414 
415  virtual std::string GetWindowTitleFromAPI() { return "VTK - VR"; }
416 
417  virtual bool CreateFramebuffers(uint32_t viewCount = 2) = 0;
418  void RenderFramebuffer(FramebufferDesc& framebufferDesc);
419 
420  bool TrackHMD = true;
421 
422  // One per view (typically one per eye)
423  std::vector<FramebufferDesc> FramebufferDescs;
424 
426  {
427  public:
431  uint32_t Index = 0;
432  };
433 
434  std::map<uint32_t, DeviceData> DeviceHandleToDeviceDataMap;
435  uint32_t InvalidDeviceIndex = UINT32_MAX;
436 
437  // -Z axis of the Physical to World matrix
438  double PhysicalViewDirection[3] = { 0.0, 0.0, -1.0 };
439  // Y axis of the Physical to World matrix
440  double PhysicalViewUp[3] = { 0.0, 1.0, 0.0 };
441  // Inverse of the translation component of the Physical to World matrix, in mm
442  double PhysicalTranslation[3] = { 0.0, 0.0, 0.0 };
443  // Scale of the Physical to World matrix
444  double PhysicalScale = 1.0;
445 
446  bool BaseStationVisibility = false;
447 
449 
450 private:
451  vtkVRRenderWindow(const vtkVRRenderWindow&) = delete;
452  void operator=(const vtkVRRenderWindow&) = delete;
453 };
454 
455 #endif
OpenGL rendering window.
void * GetGenericParentId() override
Implement required virtual functions.
void GetRenderBufferSize(int &width, int &height)
Get the frame buffers used for rendering.
virtual bool GetDeviceToWorldMatrixForDevice(vtkEventDataDevice device, vtkMatrix4x4 *deviceToWorldMatrix)
Store in deviceToWorldMatrix the matrix that goes from device coordinates to world coordinates...
represent and manipulate 4x4 transformation matrices
Definition: vtkMatrix4x4.h:41
void Start(void) override
Begin the rendering process.
void Render() override
Handle opengl specific code and calls superclass.
const char * ReportCapabilities() override
Get report of capabilities for the render window.
VR rendering window.
void DestroyWindow() override
Destroy a not-off-screen window.
abstract specification for renderers
Definition: vtkRenderer.h:72
virtual void AddRenderer(vtkRenderer *)
Add a renderer to the list of renderers.
virtual vtkRenderWindowInteractor * MakeRenderWindowInteractor()
Create an interactor to control renderers in this window.
virtual bool IsCurrent()
Tells if this window is the current graphics context for the calling thread.
virtual void Finalize()
Finalize the rendering process.
int SupportsOpenGL() override
Does this render window support OpenGL? 0-false, 1-true.
GLuint GetRightResolveBufferId()
Get the frame buffers used for rendering.
void * GetGenericDisplayId() override
Implement required virtual functions.
int vtkTypeBool
Definition: vtkABI.h:69
VR device model.
Definition: vtkVRModel.h:39
window superclass for vtkRenderWindow
Definition: vtkWindow.h:38
void * GetGenericContext() override
Implement required virtual functions.
platform-independent render window interaction including picking and frame rate control.
vtkNew< vtkMatrix4x4 > DeviceToPhysicalMatrix
virtual void SetSize(int width, int height)
Set the size (width and height) of the rendering window in screen coordinates (in pixels)...
OpenGL state storage.
virtual std::string GetWindowTitleFromAPI()
void * GetGenericWindowId() override
Implement required virtual functions.
a simple class to control print indentation
Definition: vtkIndent.h:39
a virtual camera for 3D rendering
Definition: vtkCamera.h:51
virtual int * GetScreenSize()
Get the current size of the screen in pixels.
Definition: vtkWindow.h:105
void * GetGenericDrawable() override
Implement required virtual functions.
vtkEventDataDevice
platform-independent event data structures
Definition: vtkEventData.h:25
virtual void MakeCurrent()
Make the window current.
Definition: vtkWindow.h:246
std::vector< FramebufferDesc > FramebufferDescs
GLuint GetLeftResolveBufferId()
Get the frame buffers used for rendering.
virtual void ReleaseCurrent()
Release the current context.
Definition: vtkWindow.h:252
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkTypeBool IsDirect() override
Is this render window using hardware acceleration? 0-false, 1-true.
void CreateAWindow() override
Create a not-off-screen window.
vtkOpenGLFramebufferObject * RenderFramebuffer
vtkSmartPointer< vtkVRModel > Model
std::map< uint32_t, DeviceData > DeviceHandleToDeviceDataMap
virtual vtkOpenGLState * GetState()
virtual void GetPhysicalToWorldMatrix(vtkMatrix4x4 *matrix)
Get physical to world transform matrix.
void SetSize(int a[2]) override
Set the size of the window in screen coordinates in pixels.
virtual void UpdateHMDMatrixPose()
Update the HMD pose.
virtual void Initialize(void)
Initialize the rendering window.
int CreateFramebuffers(int width, int height)
Create the offScreen framebuffer Return if the creation was successful or not.
void ReleaseGraphicsResources(vtkWindow *) override
Free up any graphics resources associated with this window a value of NULL means the context may alre...
vtkTypeBool GetEventPending() override
Check to see if a mouse button has been pressed or mouse wheel activated.
vtkOpenGLRenderWindow * HelperWindow