vtkZSpaceSDKManager.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 vtkZSpaceSDKManager_h
#define vtkZSpaceSDKManager_h
 
#include "vtkNew.h" // for vtkNew
#include "vtkObject.h"
#include "vtkRenderingZSpaceModule.h" // for export macro
 
#include <vector> // for std::vector
 
VTK_ABI_NAMESPACE_BEGIN
 
class vtkRenderWindow;
class vtkCamera;
class vtkMatrix4x4;
class vtkTransform;
class vtkPVZSpaceView;
 
class VTKRENDERINGZSPACE_EXPORT vtkZSpaceSDKManager : public vtkObject
{
public:
  vtkTypeMacro(vtkZSpaceSDKManager, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkZSpaceSDKManager* GetInstance();
 
  virtual void InitializeZSpace() = 0;
 
  virtual void UpdateViewport() = 0;
 
  virtual void UpdateTrackers() = 0;
 
  virtual void UpdateViewAndProjectionMatrix() = 0;
 
  virtual void UpdateButtonState() = 0;
 
  virtual void CalculateFrustumFit(
    const double bounds[6], double position[3], double viewUp[3]) = 0;
 
 
  virtual void BeginFrame() = 0;
  virtual void EndFrame() = 0;
 
  virtual void ShutDown(){};
 
 
  virtual void EnableGraphicsBinding(){};
  virtual void SubmitFrame(unsigned int vtkNotUsed(leftText), unsigned int vtkNotUsed(rightText)){};
  virtual void GetPerEyeImageResolution(int* vtkNotUsed(width), int* vtkNotUsed(height)){};
  virtual void SetStereoDisplayEnabled(bool vtkNotUsed(enabled)){};
  virtual bool GetStereoDisplayEnabled() { return false; };
 
  enum StereoDisplayMode
  {
    QUAD_BUFFER_STEREO = 0,
    STEREO_DISPLAY_API = 1
  };
 
  virtual StereoDisplayMode GetStereoDisplayMode() { return QUAD_BUFFER_STEREO; };
 
 
  virtual void SetRenderWindow(vtkRenderWindow* renderWindow);
 
  void Update();
 
  vtkGetMacro(WindowX, int);
 
  vtkGetMacro(WindowY, int);
 
  vtkGetMacro(WindowWidth, int);
 
  vtkGetMacro(WindowHeight, int);
 
  vtkGetMacro(StylusTargets, int);
 
  vtkGetMacro(HeadTargets, int);
 
  vtkGetMacro(SecondaryTargets, int);
 
 
  vtkGetMacro(InterPupillaryDistance, float);
  vtkSetClampMacro(InterPupillaryDistance, float, 0.f, 1.f);
 
  void SetClippingRange(const float nearPlane, const float farPlane);
 
  vtkGetMacro(ViewerScale, float);
 
  vtkGetMacro(NearPlane, float);
 
  vtkGetMacro(FarPlane, float);
 
  vtkGetObjectMacro(CenterEyeViewMatrix, vtkMatrix4x4);
 
  vtkMatrix4x4* GetStereoViewMatrix(bool leftEye);
 
  vtkGetObjectMacro(CenterEyeProjectionMatrix, vtkMatrix4x4);
 
  vtkMatrix4x4* GetStereoProjectionMatrix(bool leftEye);
 
  vtkGetObjectMacro(StylusMatrixColMajor, vtkMatrix4x4);
 
  vtkGetObjectMacro(StylusMatrixRowMajor, vtkMatrix4x4);
 
  vtkGetObjectMacro(StylusTransformRowMajor, vtkTransform);
 
  enum ButtonIds
  {
    MiddleButton = 0,
    RightButton = 1,
    LeftButton = 2,
    NumberOfButtons = 3
  };
 
  enum ButtonState
  {
    Down = 0,
    Pressed = 1,
    Up = 2,
    None = 3,
    NumberOfStates = 4
  };
 
 
  vtkGetMacro(LeftButtonState, int);
  vtkSetEnumMacro(LeftButtonState, ButtonState);
 
 
  vtkGetMacro(MiddleButtonState, int);
  vtkSetEnumMacro(MiddleButtonState, ButtonState);
 
 
  vtkGetMacro(RightButtonState, int);
  vtkSetEnumMacro(RightButtonState, ButtonState);
 
protected:
  vtkZSpaceSDKManager();
  ~vtkZSpaceSDKManager() override;
 
  vtkRenderWindow* RenderWindow = nullptr;
 
  vtkNew<vtkMatrix4x4> CenterEyeViewMatrix;
  vtkNew<vtkMatrix4x4> LeftEyeViewMatrix;
  vtkNew<vtkMatrix4x4> RightEyeViewMatrix;
  vtkNew<vtkMatrix4x4> CenterEyeProjectionMatrix;
  vtkNew<vtkMatrix4x4> LeftEyeProjectionMatrix;
  vtkNew<vtkMatrix4x4> RightEyeProjectionMatrix;
 
  // In column major format, used by openGL
  vtkNew<vtkMatrix4x4> StylusMatrixColMajor;
 
  // In row major format, used by VTK
  vtkNew<vtkMatrix4x4> StylusMatrixRowMajor;
  vtkNew<vtkTransform> StylusTransformRowMajor;
 
  int WindowX = 0;
  int WindowY = 0;
  int WindowWidth = 0;
  int WindowHeight = 0;
 
  // Store the type for each detected display devices
  std::vector<std::string> Displays;
  // The number of stylus
  int StylusTargets = 0;
  // The number of glasses
  int HeadTargets = 0;
  // Additional targets
  int SecondaryTargets = 0;
 
  // Inter pupillary distance in meters
  float InterPupillaryDistance = 0.056f;
  float ViewerScale = 1.f;
  // Camera near plane
  float NearPlane = 0.0001f;
  // Camera far plane
  float FarPlane = 1000.f;
 
  // For interactions, store the state of each buttons
  ButtonState LeftButtonState = None;
  ButtonState MiddleButtonState = None;
  ButtonState RightButtonState = None;
  // Store buttons state to iterate over them
  ButtonState* ButtonsState[NumberOfButtons] = { &MiddleButtonState, &RightButtonState,
    &LeftButtonState };
 
private:
  vtkZSpaceSDKManager(const vtkZSpaceSDKManager&) = delete;
  void operator=(const vtkZSpaceSDKManager&) = delete;
};
 
VTK_ABI_NAMESPACE_END
 
#endif