vreVrvExtensions.h

Go to the documentation of this file.

/*********************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*********************************************************************************/
 
//! \file vreVrvExtensions.h
//! \brief Provides VREngage-specific extensions to the VR-Vantage runtime system
//!
//! This file contains declarations of classes needed to override the type of
//! reflected entity list created in a DtVrlinkConnection. By default, VR-Vantage
//! creates reflected entity list derived from DtReflectedEntityList. However, VR-Engage
//! creates a DtVrfRemoteController that requires a DtReflectedExtEntityList. Therefore
//! the reflected entity list created by VR-Vantage must be a DtReflectedExtEntityList,
//! enabling a single list to be used and shared by multiple classes in the VR-Engage
//! front-end. Overriding this requires replacing the DtReflectedEntityList and
//! DtEntityStateRepository with corresponding DtReflectedExtEntityList and
//! DtExtEntityStateRepository types.
//!
//! DtVreEntityReflectedListCreator and DtVreEntityStateInterceptorCreator instances
//! are registered in DtConnectorAccessory::slot_onSimCreated(), ensuring that our
//! derived reflected list and derived state repository classes get created by VR-Vantage.
 
#pragma once
 
#include "vrePlayerStationConnector/export.h"
 
#include <vrvVrl/DtVrlinkConnection.h>
#include <vrvVrl/DtEntityStateInterceptorCreator.h>
#include <vrvVrl/DtCustomReflectedEntityList.h>
#include <vrvVrl/DtVrlinkReflectedAerodromeList.h>
#include <vrfExtObjects/extEntityStateRepository.h>
 
#include <vreMessageManager/vreMessage.h>
#include <vrfobjparam/smsLoader.h>
 
class DtReflectedExtEntityList;
class DtReflectedExtEntity;
class DtExtEntityStateRepository;
 
 
namespace makVre
{
//! \brief Type of derived reflected entity list to create in VR-Vantage's DtVrlinkConnection
//!
//! This type alias defines a custom reflected entity list based on DtReflectedExtEntityList,
//! DtReflectedExtEntity, and DtExtEntityStateRepository classes
using DtVreBaseCustomReflectedEntityList = makVrv::DT_PROTOCOL_NAMESPACE::DtCustomReflectedEntityList<
   DtReflectedExtEntityList, DtReflectedExtEntity, DtExtEntityStateRepository>;
 
//! \brief VREngage-specific implementation of the reflected entity list
//!
//! Extends the base custom reflected entity list to provide VREngage-specific functionality,
//! including parameter database handling and interaction with simulation model sets.
class VRL_DLL DtVreCustomReflectedEntityList : public DtVreBaseCustomReflectedEntityList
{
public:
   //! \brief Constructor for non-HLA protocols
   //! \param listener Reference to the entity element processor that will receive entity events
   DtVreCustomReflectedEntityList(makVrv::DT_PROTOCOL_NAMESPACE::DtEntityElementProcessor& listener)
      : DtVreBaseCustomReflectedEntityList(listener)
   {
   }
 
#if defined(DtHLA)
   //! \brief Constructor for HLA protocol
   //! \param listener Reference to the entity element processor that will receive entity events
   //! \param regionsToUse Reference to the DDM regions to use for this entity list
   DtVreCustomReflectedEntityList(
      makVrv::DT_PROTOCOL_NAMESPACE::DtEntityElementProcessor& listener, const DtDDMRegionSet& regionsToUse)
      : DtVreBaseCustomReflectedEntityList(listener, regionsToUse)
   {
   }
#endif
 
   //! \brief Virtual destructor
   //!
   //! Removes message handlers registered during initialization
   virtual ~DtVreCustomReflectedEntityList() override;
 
   //! \brief Initializes the reflected entity list
   //!
   //! Registers parameter factories for various entity types and sets up
   //! message handlers for simulation model set handling
   virtual void initialize();
 
   //! \brief Handles a newly added entity
   //! \param ent Pointer to the entity that was added
   //!
   //! Registers a callback for entity updates and performs base class handling
   virtual void entityAdded(DtReflectedEntity* ent) override;
 
   //! \brief Determines if an entity is ready to be added to the list
   //! \param obj Pointer to the reflected object to check
   //! \return True if the entity should be added, false otherwise
   //!
   //! Called when an entity has been discovered and needs to be added to the list
   virtual bool readyToAdd(DtReflectedObject* obj) override;
 
   //! \brief Static callback function for entity updates
   //! \param entity Pointer to the entity that was updated
   //! \param usr User data pointer (points to the DtVreCustomReflectedEntityList instance)
   static void entityUpdatedCallback(DtReflectedEntity* entity, void* usr);
 
   //! \brief Handles entity updates
   //! \param ent Pointer to the entity that was updated
   //!
   //! Overridden function to process entity updates
   virtual void entityUpdated(DtReflectedEntity* ent) override;
 
   //! \brief Gets the parameter database associated with this entity list
   //! \return Pointer to the parameter database
   //!
   //! Returns the parameter database from the SMS loader
   DtVrfParameterDb* parameterDatabase();
 
protected:
   //! \brief Discovers and initializes an entity with parameter data
   //! \param obj Pointer to the reflected object to discover
   //! \param entSR Pointer to the entity state repository
   //!
   //! Attempts to find parameter data for the entity in the parameter database
   virtual void discoverEntity(DtReflectedObject* obj, DtExtEntityStateRepository* entSR);
 
   //! \brief Handles simulation model set list messages
   //! \param msg Pointer to the message containing the SMS list
   //! \return Message result indicating how the message was handled
   //!
   //! Ensures the SMS list has been loaded successfully and updates parameters if needed
   virtual DtVreMessageResult handleSessionSmsList(DtVreMessage* msg);
 
protected:
   //! \brief Loader for simulation model sets
   DtSmsLoader mySmsLoader;
 
   //! \brief Currently loaded simulation model set filenames
   std::vector<std::string> mySms;
 
   //! \brief Type alias for mapping reflected objects to entity types
   using InitializedTypeMap = std::map<DtReflectedObject*, DtEntityType>;
 
   //! \brief Map of reflected objects to their entity types
   //!
   //! Tracks which entities have been initialized with which entity types
   InitializedTypeMap myInitializedWithType;
 
   //! \brief Type alias for the set of missing entity types
   using MissingTypeSet = std::set<DtEntityType>;
 
   //! \brief Set of entity types we know aren't in the parameter database
   //!
   //! This prevents entities with unknown parameter types from searching
   //! the parameter database every time there's a network update
   MissingTypeSet myMissingTypes;
};
 
//! \brief Creator class for DtVreCustomReflectedEntityList instances
//!
//! This class overrides the default entity reflected list creator to produce
//! VREngage-specific reflected entity lists
class VRL_DLL DtVreEntityReflectedListCreator : public makVrv::DT_PROTOCOL_NAMESPACE::DtVrvEntityReflectedListCreator
{
public:
   //! \brief Gets or creates the singleton instance for a specific connection
   //! \param sim Reference to the VR-Link connection to associate with this creator
   //! \return Reference to the singleton instance
   static DtVrvEntityReflectedListCreator& instance(makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkConnection& sim);
 
   //! \brief Creates a new reflected entity list
   //! \param listener Reference to the entity element processor that will receive entity events
   //! \return Pointer to the newly created reflected entity list
   //!
   //! Creates a DtVreCustomReflectedEntityList instance and initializes it
   virtual DtReflectedEntityList* create(makVrv::DT_PROTOCOL_NAMESPACE::DtEntityElementProcessor& listener) override;
 
#if defined(DtHLA)
   //! \brief Creates a new reflected entity list with DDM regions (HLA-specific)
   //! \param l Reference to the entity element processor that will receive entity events
   //! \param r Reference to the DDM regions to use
   //! \return Pointer to the newly created reflected entity list
   virtual DtReflectedEntityList* create(makVrv::DT_PROTOCOL_NAMESPACE::DtEntityElementProcessor& l,
      const DtDDMRegionSet& r) override;
#endif
 
protected:
   //! \brief Constructor
   //! \param sim Reference to the VR-Link connection to associate with this creator
   DtVreEntityReflectedListCreator(makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkConnection& sim);
};
 
//! \brief Creator class for the DtEntityStateRepository derived from DtExtEntityStateRepository
//!
//! This class overrides the default entity state interceptor creator to produce
//! VREngage-specific entity state repositories
class VRL_DLL DtVreEntityStateInterceptorCreator : public makVrv::DT_PROTOCOL_NAMESPACE::DtEntityStateInterceptorCreator
{
public:
   //! \brief Gets or creates the singleton instance for a specific connection
   //! \param sim Reference to the VR-Link connection to associate with this creator
   //! \return Reference to the singleton instance
   static DtEntityStateInterceptorCreator& instance(makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkConnection& sim);
 
   //! \brief Default constructor
   DtVreEntityStateInterceptorCreator();
 
   //! \brief Virtual destructor
   virtual ~DtVreEntityStateInterceptorCreator() override;
 
   //! \brief Creates a new entity state repository
   //! \param listener Pointer to the entity state listener that will receive entity state events
   //! \return Pointer to the newly created entity state repository
   //!
   //! Creates an entity state interceptor using DtExtEntityStateRepository
   virtual DtEntityStateRepository* create(makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkEntityStateListener* listener) override;
};
 
//! \brief Creator class for aerodrome reflected lists
//!
//! This class overrides the default aerodrome reflected list creator to produce
//! VREngage-specific aerodrome reflected lists based on DtReflectedExtAerodromeList
class VRL_DLL DtVreAerodromeReflectedListCreator
   : public makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkReflectedAerodromeListCreator
{
public:
   //! \brief Gets or creates the singleton instance for a specific connection
   //! \param sim Reference to the VR-Link connection to associate with this creator
   //! \return Reference to the singleton instance
   static makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkReflectedAerodromeListCreator& instance(
      makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkConnection& sim);
 
   //! \brief Creates a new aerodrome reflected list
   //! \param l Reference to the aerodrome existence listener
   //! \return Pointer to the newly created aerodrome reflected list
   virtual DtReflectedAerodromeList* create(makVrv::DT_PROTOCOL_NAMESPACE::DtAerodromeExistenceListener& l) override;
#if defined(DtHLA)
   //! \brief Creates a new aerodrome reflected list with DDM regions (HLA-specific)
   //! \param l Reference to the aerodrome existence listener
   //! \param s Pointer to the DDM regions to use
   //! \return Pointer to the newly created aerodrome reflected list
   virtual DtReflectedAerodromeList* create(
      makVrv::DT_PROTOCOL_NAMESPACE::DtAerodromeExistenceListener& l, const DtDDMRegionSet* s) override;
#endif
 
protected:
   //! \brief Constructor
   //! \param sim Reference to the VR-Link connection to associate with this creator
   DtVreAerodromeReflectedListCreator(makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkConnection& sim);
};
 
} // namespace makVre