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`.
  //---------------------------------------------------------------------------
 
  const std::string& GetHostName() const { return this->HostName; }
 
  const std::string& GetClientHostName() const { return this->ClientHostName; }
 
  vtkGetMacro(ServerPort, int);
 
  vtkGetMacro(ReverseConnection, bool);
 
  vtkGetMacro(ConnectID, int);
 
  vtkSetMacro(ConnectID, int);
 
  vtkGetMacro(Timeout, int);
 
  const std::string& GetTimeoutCommand() const { return this->TimeoutCommand; }
 
  vtkGetMacro(TimeoutCommandInterval, int);
 
  const std::string& GetServerURL() const { return this->ServerURL; }
 
  const std::string& GetServerResourceName() const { return this->ServerResourceName; }
 
  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;
 
  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);
 
  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";
  int ServerPort = 11111;
  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;
  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