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

  static std::string ButtonToString(ButtonIds buttonId);
 
  enum ButtonState
  {
    Down = 0,
    Pressed = 1,
    Up = 2,
    None = 3,
    NumberOfStates = 4
  };

  struct StylusEventData
  {
    StylusEventData(ButtonIds button, ButtonState state)
      : Button(button)
      , State(state)
    {
    }
 
    ButtonIds Button;
    ButtonState State;
  };


  ButtonState GetButtonState(ButtonIds buttonId) const;
  void SetButtonState(ButtonIds buttonId, ButtonState buttonState);


  vtkGetMacro(LeftButtonState, int);
  vtkSetEnumMacro(LeftButtonState, ButtonState);


  vtkGetMacro(MiddleButtonState, int);
  vtkSetEnumMacro(MiddleButtonState, ButtonState);


  vtkGetMacro(RightButtonState, int);
  vtkSetEnumMacro(RightButtonState, ButtonState);


  bool GetUseDefaultBehavior(ButtonIds buttonId) const;
  void SetUseDefaultBehavior(ButtonIds buttonId, bool enabled);
 
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 };
 
  // Store whether or not to use the default behavior per button.
  bool DefaultStylusButtonEventsEnabled[NumberOfButtons] = { true, true, true };
 
private:
  vtkZSpaceSDKManager(const vtkZSpaceSDKManager&) = delete;
  void operator=(const vtkZSpaceSDKManager&) = delete;
};
 
VTK_ABI_NAMESPACE_END
 
#endif