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 "vtkWrappingHints.h"     // For VTK_MARSHALAUTO
#include "vtk_glad.h"             // used for methods

#include <vector> // ivars

VTK_ABI_NAMESPACE_BEGIN
class vtkCamera;
class vtkMatrix4x4;
class vtkVRModel;

class VTKRENDERINGVR_EXPORT VTK_MARSHALAUTO vtkVRRenderWindow : public vtkOpenGLRenderWindow
{
public:
  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);

  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;


  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;

  // 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;

  bool BaseStationVisibility = false;

  vtkOpenGLRenderWindow* HelperWindow;

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

VTK_ABI_NAMESPACE_END
#endif