vrfLaunchConnector.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file vrfLaunchConnector.h
//! \brief Defines the DtVrfLaunchConnector class for launching VR-Forces backends
//!
//! This connector provides functionality to configure and launch VR-Forces simulation
//! backends with various options for protocols, plugins, and runtime parameters.
 
#pragma once
 
#include "export.h"
 
#include "vrePlayerStationConnector/simEventConnector.h"
#include "vreMessageManager/vreMessage.h"
 
#include <vl/exerciseConnInitializer.h>
 
//! \brief Forward declaration of the exercise connection class
class DtExerciseConn;
 
//! \brief Forward declaration of the simulation address class
class DtSimulationAddress;
 
namespace makVre
{
//! \brief Connector for launching and configuring VR-Forces backends
//!
//! DtVrfLaunchConnector handles the configuration and launching of VR-Forces
//! simulation backends. It generates command lines with appropriate parameters
//! based on connection settings, protocol-specific options, and user-specified
//! arguments, then launches the backend process.
class VRL_DLL DtVrfLaunchConnector : public DT_PROTOCOL_NAMESPACE::DtSimEventConnector
{
public:
   //! \brief Default constructor
   DtVrfLaunchConnector();
 
   //! \brief Virtual destructor
   virtual ~DtVrfLaunchConnector() override;
 
   //! \brief Generates a command line for launching the simulation engine
   //! \param address The site/app ID to use
   //! \param sessionId VR-Engage's session ID
   //! \param simType Integer representing the type of simulation use
   //!        (full VR-Forces sim engine, ownship-only sim engine, or limited backend)
   //! \param pluginBaseNames List of plugin names specified in appData\scripts\playerStation.lua
   //! \param additionalArguments Value of additionalBackendCommandLineParameters
   //!        defined in playerStation.lua (modified by this function)
   //! \return The full simulation engine launch command string
   //!
   //! Builds a complete command line for launching a VR-Forces backend with
   //! appropriate connection parameters, plugins, and user-specified arguments.
   //! Some connection parameters in additionalArguments may be removed and replaced.
   std::string vrfSimEngineCommand(const DtSimulationAddress& address, int sessionId, int simType,
      const std::vector<std::string>& pluginBaseNames, std::string& additionalArguments);
 
   //! \brief Installs the VR-Forces launch connector with the application and connection
   //! \param app Pointer to the player station application
   //! \param connection Pointer to the protocol-specific VR-Link connection
   //! \param exerciseConnInitializer Pointer to the exercise connection initializer
   //!
   //! Initializes the connector with the provided connection information and
   //! registers message handlers for backend configuration and launch requests
   virtual void install(DtPlayerStationApp* app, makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkConnection* connection,
      const DtExerciseConnInitializer* exerciseConnInitializer);
 
   //! \brief Performs periodic processing (currently empty implementation)
   virtual void tick() override;
 
   //! \brief Shuts down the VR-Forces launch connector
   virtual void shutdown() override;
 
protected:
   //! \brief Handles messages to set backend configuration
   //! \param msg Pointer to the backend configuration message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes configuration messages to set session ID, plugins, RTDynamics,
   //! console visibility, and command line arguments
   virtual makVre::DtVreMessageResult handleSetBackendConfig(makVre::DtVreMessage* msg);
 
   //! \brief Handles messages to launch a simulation process
   //! \param msg Pointer to the launch simulation message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes launch requests by calling launchVrfBackend with the
   //! current configuration settings
   virtual makVre::DtVreMessageResult handleLaunchSimProcess(makVre::DtVreMessage* msg);
 
   //! \brief Launches a simulation engine with specified parameters
   //! \param address The site/app ID to use
   //! \param sessionId VR-Engage's session ID
   //! \param simType Integer representing the type of simulation to use
   //! \param pluginBaseNames List of plugin names to include
   //! \param showConsole Flag indicating whether to show the console window
   //! \param additionalArguments Additional command line arguments
   //!
   //! Launches a VR-Forces backend process with the specified configuration.
   //! See vrfSimEngineCommand for details on command line generation.
   virtual void launchVrfBackend(const DtSimulationAddress& address, int sessionId, int simType,
      const std::vector<std::string>& pluginBaseNames, bool showConsole,
      std::string& additionalArguments);
 
   //! \brief Gets the application executable path
   //! \return String containing the path to the application executable
   //!
   //! Provides the protocol-specific path to the VR-Forces application executable
   virtual std::string application() const;
 
   //! \brief Generates connection-specific settings string
   //! \param address The site/app ID to use
   //! \param additionalArguments User-defined arguments from playerStation.lua
   //! \return String containing all relevant connection parameters
   //!
   //! Creates a string with protocol-specific connection parameters for
   //! the VR-Forces backend, merging with user-specified additional arguments
   virtual std::string connectionParameters(const DtSimulationAddress& address, std::string& additionalArguments) const;
 
   //! \brief Gets the protocol name
   //! \return String containing the protocol name (DIS, HLA 1.3, HLA 1516, or HLA 1516e)
   //!
   //! Returns the protocol-specific name used in command line parameters
   virtual std::string protocol() const;
 
protected:
   //! \brief Pointer to the exercise connection initializer
   //!
   //! Contains connection settings like federation name, exercise ID, etc.
   const DtExerciseConnInitializer* myExerciseConnInitializer;
 
   //! \brief Session ID for the backend
   //!
   //! Used to uniquely identify this session in the simulation
   int mySessionId;
 
   //! \brief List of plugin base names to load
   std::vector<std::string> myPlugins;
 
   //! \brief Flag indicating whether to show the console window
   bool myShowConsole;
 
   //! \brief Additional command line arguments
   std::string myArguments;
};
} // namespace makVre