vreCommunicationManager.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
 
//! \file vreCommunicationManager.h
//! \ingroup vrePlayerStation.dll
//! \brief Contains the DtVreCommunicationManager class for connecting and managing communication with VR-Link.
 
#pragma once
 
#include "export.h"
 
#include "vreMessageManager/vreMessage.h"
 
#include <vrfMsgTransport/communicationManager.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <boost/signals2.hpp>
 
#include <set>
 
namespace makVrv
{
class DtBaseConnection;
} // namespace makVrv
 
class DtMtlParameterDb;
class DtSimulationModelSet;
 
namespace makVre
{
//! \brief This class manages communication between player stations and VR-Link connections
//!
//! DtVreCommunicationManager provides functionality for managing simulation model sets,
//! parameter databases, and frame updates. It serves as a bridge between the player station
//! and the underlying VR-Link connection, handling pre and post thread ticks for frame advancement.
class MESSAGEMANAGER_DLL DtVreCommunicationManager : public DtCommunicationManager, public makVrv::DtVirtualBaseClass
{
public:
   //! \brief Constructor for the communication manager
   //! \param addr The simulation address to be used
   //! \param sm Pointer to the state data manager (optional)
   //! \param threadPoolSize Size of the thread pool; -1 uses default size
   DtVreCommunicationManager(
      const DtSimulationAddress& addr, makVrf::DtStateDataManager* sm = 0, int threadPoolSize = -1);
 
   //! \brief Virtual destructor
   virtual ~DtVreCommunicationManager() override;
 
   //! \brief Gets or creates a singleton instance of DtVreCommunicationManager for the given connection
   //! \param conn Reference to the VR-Link connection to associate with the instance
   //! \return Reference to the singleton instance
   //!
   //! If an instance doesn't exist, one will be created and registered with the connection
   static DtVreCommunicationManager& instance(makVrv::DtBaseConnection& conn);
 
   //! \brief Registers an instance with the connection and connects it for updates
   //! \param sim Reference to the VR-Link connection
   //! \param instance Pointer to the instance to register
   static void registerInstance(
      makVrv::DtBaseConnection& sim, DtVreCommunicationManager* instance);
 
   //! \brief Factory method to create a new communication manager
   //! \param addr The simulation address to use
   //! \param sm Pointer to the state data manager (optional)
   //! \param threadPoolSize Size of the thread pool; -1 uses default size
   //! \return Pointer to a newly created DtCommunicationManager
   static DtCommunicationManager* creator(
      const DtSimulationAddress& addr, makVrf::DtStateDataManager* sm = 0, int threadPoolSize = -1);
 
   //! \brief Connects for pre/post tick to be able to advance frame
   //! \param vrlConn Reference to the VR-Link connection to connect to
   //!
   //! This function connects the manager to the pre and post tick signals of the VR-Link connection,
   //! allowing automatic frame advancement. Call disconnectForUpdate to disable this
   //! and handle the updates yourself.
   virtual void connectForUpdate(makVrv::DtBaseConnection& vrlConn);
 
   //! \brief Disconnects from pre/post tick signals
   //!
   //! Disconnects the manager from the pre and post tick signals,
   //! disabling automatic frame advancement.
   virtual void disconnectForUpdate();
 
   //! \brief Sets the simulation model sets from a vector of DtFilename objects
   //! \param smss Vector of DtFilename objects representing simulation model sets
   //! \return True if the model sets were changed, false otherwise
   virtual bool setSimulationModelSets(const std::vector<DtFilename>& smss);
 
   //! \brief Sets the simulation model sets from a vector of strings
   //! \param smss Vector of strings representing simulation model sets
   //! \return True if the model sets were changed, false otherwise
   virtual bool setSimulationModelSets(const std::vector<std::string>& smss);
 
   //! \brief Sets the simulation model sets from a set of strings
   //! \param smss Set of strings representing simulation model sets
   //! \return True if the model sets were changed, false otherwise
   virtual bool setSimulationModelSets(const std::set<std::string>& smss);
 
   //! \brief Sets the simulation model sets from a vector of DtString objects
   //! \param smss Vector of DtString objects representing simulation model sets
   //! \return True if the model sets were changed, false otherwise
   virtual bool setSimulationModelSets(const std::vector<DtString>& smss);
 
   //! \brief Adds a single simulation model set
   //! \param sms String representing the simulation model set to add
   virtual void addSimulationModelSet(const std::string& sms);
 
   //! \brief Clears all simulation model sets
   virtual void clearSimModelSets();
 
   //! \brief Gets the current simulation model sets
   //! \return Constant reference to the vector of simulation model sets
   virtual const std::vector<DtFilename>& simulationModelSets() { return mySimulationModelSets; };
 
   //! \brief Sets the parameter database for the communication manager
   //! \param parameterDb Pointer to the parameter database to use
   //! \note The parameter database is cast to DtMtlParameterDb internally
   virtual void setParameterDatabase(DtVrfParameterDb* parameterDb) override;
 
protected:
   //! \brief Slot called before each thread tick
   //!
   //! Calls beginFrame to prepare for the next simulation frame
   virtual void slot_preThreadTick();
 
   //! \brief Slot called after each thread tick
   //!
   //! Calls advanceFrame to complete the current simulation frame and
   //! handles parameter database updates if simulation model sets have changed
   virtual void slot_postThreadTick();
 
   //! \brief Sets up the parameter database with the current simulation model sets
   //! \return True if the parameter database was set up successfully, false otherwise
   //!
   //! Creates a new parameter database if one doesn't exist, then loads all OPD files
   //! from the simulation model sets into the database
   virtual bool setupParameterDatabase();
 
   //! \brief Parses OPD files from a simulation model set
   //! \param smsToLoad The simulation model set to load
   //! \param opdFiles Vector to store the found OPD files
   //! \param searchPaths Vector to store the search paths
   //!
   //! Recursively processes included simulation model sets and collects
   //! all OPD files and search paths
   virtual void parseOPDFiles(
      const DtFilename& smsToLoad, std::vector<DtFilename>& opdFiles, std::vector<DtFilename>& searchPaths);
 
protected:
   //! \brief Connection to the pre-tick signal
   boost::signals2::scoped_connection myPreTickConnection;
 
   //! \brief Connection to the post-tick signal
   boost::signals2::scoped_connection myPostTickConnection;
 
   //! \brief Pointer to the parameter database
   DtMtlParameterDb* myParamDB;
 
   //! \brief Last used search paths for the parameter database
   std::vector<DtFilename> myLastSearchPaths;
 
   //! \brief Current simulation model sets
   std::vector<DtFilename> mySimulationModelSets;
 
   //! \brief Flag indicating whether simulation model sets have changed
   bool mySmsChanged;
 
   //! \brief Timer for parameter database updates
   double myParamDBTimerStart;
};
} // namespace makVre