vtkRemotingCoreConfiguration.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkRemotingCoreConfiguration_h
#define vtkRemotingCoreConfiguration_h

#include "vtkObject.h"
#include "vtkProcessModule.h"      // for vtkProcessModule::ProcessTypes
#include "vtkRemotingCoreModule.h" //needed for exports
#include <string>                  // for std::string
#include <utility>                 // for std::pair
#include <vector>                  // for std::vector

class vtkCLIOptions;
class vtkDisplayConfiguration;

class VTKREMOTINGCORE_EXPORT vtkRemotingCoreConfiguration : public vtkObject
{
public:
  vtkTypeMacro(vtkRemotingCoreConfiguration, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  static vtkRemotingCoreConfiguration* GetInstance();

  //---------------------------------------------------------------------------
  // Options added using `PopulateGlobalOptions`
  //---------------------------------------------------------------------------

  vtkGetMacro(TellVersion, bool);

  vtkGetMacro(DisableRegistry, bool);

  vtkGetMacro(PrintMonitors, bool);

  //---------------------------------------------------------------------------
  // Options added using `PopulateConnectionOptions`.
  //---------------------------------------------------------------------------


  vtkSetMacro(HostName, std::string);
  vtkGetMacro(HostName, std::string);


  vtkSetMacro(ClientHostName, std::string);
  vtkGetMacro(ClientHostName, std::string);


  vtkSetMacro(ServerPort, int);
  vtkGetMacro(ServerPort, int);


  vtkSetMacro(BindAddress, std::string);
  vtkGetMacro(BindAddress, std::string);


  vtkSetMacro(ReverseConnection, bool);
  vtkGetMacro(ReverseConnection, bool);


  vtkSetMacro(ConnectID, int);
  vtkGetMacro(ConnectID, int);


  vtkSetMacro(Timeout, int);
  vtkGetMacro(Timeout, int);


  vtkSetMacro(TimeoutCommand, std::string);
  vtkGetMacro(TimeoutCommand, std::string);


  vtkSetMacro(TimeoutCommandInterval, int);
  vtkGetMacro(TimeoutCommandInterval, int);

  vtkGetMacro(ServerURL, std::string);

  vtkGetMacro(ServerResourceName, std::string);

  const std::vector<std::string>& GetServerConfigurationsFiles() const
  {
    return this->ServerConfigurationsFiles;
  }


  //---------------------------------------------------------------------------
  // Options added using `PopulatePluginOptions`.
  //---------------------------------------------------------------------------

  const std::vector<std::string>& GetPluginSearchPaths() const { return this->PluginSearchPaths; }

  const std::vector<std::string>& GetPlugins() const { return this->Plugins; }

  //---------------------------------------------------------------------------
  // Options added using `PopulateRenderingOptions`.
  //---------------------------------------------------------------------------

  vtkGetMacro(UseStereoRendering, bool);

  vtkGetMacro(StereoType, int);
  const char* GetStereoTypeAsString() const;

  double GetEyeSeparation() const;

  bool GetUseOffAxisProjection() const;

  vtkGetVector2Macro(TileMullions, int);

  void GetTileDimensions(int dims[2]);
  const int* GetTileDimensions();

  bool GetIsInTileDisplay() const;

  bool GetIsInCave() const;

  vtkDisplayConfiguration* GetDisplayConfiguration() const { return this->DisplayConfiguration; }

  vtkGetMacro(DisableXDisplayTests, bool);

  vtkGetMacro(ForceOffscreenRendering, bool);

  enum OpenGLWindowBackendEnum
  {
    OPENGL_WINDOW_BACKEND_DEFAULT,
    OPENGL_WINDOW_BACKEND_EGL,
    OPENGL_WINDOW_BACKEND_GLX,
    OPENGL_WINDOW_BACKEND_OSMESA,
    OPENGL_WINDOW_BACKEND_WIN32,
  };
  vtkGetMacro(OpenGLWindowBackend, OpenGLWindowBackendEnum);

  vtkGetMacro(ForceOnscreenRendering, bool);

  int GetEGLDeviceIndex();

  std::string GetDisplay();

  //---------------------------------------------------------------------------
  // Options added using `PopulateMiscellaneousOptions`.
  //---------------------------------------------------------------------------

  vtkGetMacro(MultiServerMode, bool);

  vtkGetMacro(MultiClientMode, bool);

  vtkGetMacro(DisableFurtherConnections, bool);

  //---------------------------------------------------------------------------
  bool PopulateOptions(vtkCLIOptions* app, vtkProcessModule::ProcessTypes processType);
  bool PopulateGlobalOptions(vtkCLIOptions* app, vtkProcessModule::ProcessTypes processType);
  bool PopulateConnectionOptions(vtkCLIOptions* app, vtkProcessModule::ProcessTypes processType);
  bool PopulatePluginOptions(vtkCLIOptions* app, vtkProcessModule::ProcessTypes processType);
  bool PopulateRenderingOptions(vtkCLIOptions* app, vtkProcessModule::ProcessTypes processType);
  bool PopulateMiscellaneousOptions(vtkCLIOptions* app, vtkProcessModule::ProcessTypes processType);

  void HandleDisplayEnvironment();

protected:
  vtkRemotingCoreConfiguration();
  ~vtkRemotingCoreConfiguration() override;

private:
  static vtkRemotingCoreConfiguration* New();
  vtkRemotingCoreConfiguration(const vtkRemotingCoreConfiguration&) = delete;
  void operator=(const vtkRemotingCoreConfiguration&) = delete;

  enum DisplaysAssignmentModeEnum
  {
    CONTIGUOUS,
    ROUNDROBIN
  };

  bool TellVersion = false;
  bool DisableRegistry = false;
  std::string HostName = "localhost";
  std::string ClientHostName = "localhost";
  std::string BindAddress = "0.0.0.0";
  int ServerPort = 0;
  bool ReverseConnection = false;
  int ConnectID = 0;
  std::string ServerURL;
  std::string ServerResourceName;
  int Timeout = 0;
  std::string TimeoutCommand;
  int TimeoutCommandInterval = 60;
  bool UseStereoRendering = false;
  int StereoType = 0;
  double EyeSeparation = 0.06;
  bool DisableXDisplayTests = false;
  bool ForceOnscreenRendering = false;
  bool ForceOffscreenRendering = false;
  OpenGLWindowBackendEnum OpenGLWindowBackend = OPENGL_WINDOW_BACKEND_DEFAULT;
  int EGLDeviceIndex = -1;
  DisplaysAssignmentModeEnum DisplaysAssignmentMode = ROUNDROBIN;
  bool MultiServerMode = false;
  bool MultiClientMode = false;
  bool DisableFurtherConnections = false;
  bool PrintMonitors = false;

  std::vector<std::string> Displays;
  std::vector<std::string> PluginSearchPaths;
  std::vector<std::string> Plugins;
  std::vector<std::string> ServerConfigurationsFiles;
  int TileDimensions[2] = { 0, 0 };
  int TileMullions[2] = { 0, 0 };

  vtkDisplayConfiguration* DisplayConfiguration = nullptr;
};

#endif