vreSetController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreSetController.h
//! \ingroup vreVrfmodel
//! \brief Template controller for handling VR-Engage entity control assignments
//!
//! This file defines the DtVreSetController template class which extends base set
//! controllers to handle VR-Engage specific control requests. It manages role-based
//! control assignments with multi-station support and provides resource information
//! publishing for player-controlled entities.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include "vreVrfmodel/vreSimComponent.h"
 
 
#include "vreUtil/assert.h"
#include "vreUtil/logger.h"
 
#include "vreVrfMessages/setVreControlled.h"
 
#include <vrfmsgs/setDataRequestMessage.h>
 
#include <vrfobjcore/physicalWorld.h>
#include <vrfobjcore/setDataManager.h>
#include <vrfobjcore/localObject.h>
#include <vrfobjcore/vrfMovingObjectStateRepository.h>
#include <vrfobjcore/attachedTerrain.h>
 
#include <vrftasks/setAltitudeRequest.h>
#include <vrftasks/setDataRequest.h>
 
#include <vrfutil/kinematicTools.h>
 
#include <terrainCS/coordSystem.h>
 
#include <vlutil/vlString.h>
 
class DtSimulationServices;
class DtComponentDescriptor;
class DtReaderWriterRegistry;
 
namespace makVre
{
//! \brief Template controller for handling VR-Engage entity control assignments
//! \tparam SetControllerBase The base set controller class to extend with VR-Engage functionality
//!
//! DtVreSetController is a template class that extends base set controllers with
//! VR-Engage specific functionality for handling DtSetVreControlledRequest messages.
//! These messages assign control of entity roles to specific VR-Engage player stations,
//! supporting multi-station control of a single entity with different roles.
//!
//! The controller also handles the publishing of resource information for player-controlled
//! entities and provides special handling for altitude setting commands.
//!
//! All VR-Engage specific set controllers should derive from this template class.
//!
//! Uses Descriptor Type: DtComponentDescriptor
template <typename SetControllerBase>
class VREVRFMODEL_DLL DtVreSetController : public DtVreSimComponent<SetControllerBase>
{
public:
   //! \brief Constructor
   //! \param name The name of this component
   //! \param owner The local object that owns this component
   //! \param simManager The simulation services manager
   //! \param desc Component descriptor with configuration parameters
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //!
   //! Creates a new VR-Engage set controller component with the specified parameters.
   //! Initializes the resource warning flag.
   DtVreSetController(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0)
      : DtVreSimComponent<SetControllerBase>(name, owner, simManager, desc, parentRegistry)
      , myWarnedAboutResource(false)
   {
   }
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the VR-Engage set controller component,
   //! removing the set data callback for player control requests.
   virtual ~DtVreSetController() override
   {
      this->entity()->setDataManager()->removeSetDataCallback(
         DtSetVreControlledType, setPlayerControlledCallback, (void*)this);
   }
 
   //! \brief Sets the simulation radio and registers callbacks
   //! \param radio The simulation radio to use for communication
   //!
   //! Overrides the base method to register the component's interest in
   //! DtSetVreControlledType set commands. This ensures the component will
   //! be notified when VR-Engage control assignment requests are received.
   virtual void setRadio(DtSimRadio* radio)
   {
      SetControllerBase::setRadio(radio);
 
      this->entity()->setDataManager()->addSetDataProcessorCallback(
         DtSetVreControlledType, setPlayerControlledCallback, (void*)this);
   }
 
   //! \brief Static callback function for player control messages
   //! \param msg The simulation message containing control assignment information
   //! \param usrData User data pointer, typically pointing to an instance of this class
   //!
   //! Static function registered as a callback to handle VR-Engage control messages.
   //! Forwards the message to the appropriate instance's processSetPlayerControlled method.
   static void setPlayerControlledCallback(DtSimMessage* msg, void* usrData)
   {
      ((DtVreSetController*)usrData)->processSetPlayerControlled(msg);
   }
 
   struct SetVreControlledContent
   {
      bool myControlled;
      DtString myStationId;
      std::vector<std::string> myRoles;
   };
 
   //! \brief Processes a VR-Engage control assignment message
   //! \param msg The simulation message containing control assignment information
   //!
   //! Processes DtSetVreControlledRequest messages, which assign or remove control of
   //! entity roles to specific VR-Engage player stations. For each role, maintains a list
   //! of controlling stations to support multi-station control of a single entity.
   virtual void processSetPlayerControlled(DtSimMessage* msg)
   {
      DtSetDataRequestMessage* drMsg = static_cast<DtSetDataRequestMessage*>(msg);
      DtSetVreControlledRequest* req = static_cast<DtSetVreControlledRequest*>(drMsg->setDataRequest());
 
      // Queue the changes to happen later in tick, one per tick.
      SetVreControlledContent change;
      change.myControlled = req->playerStationControlled();
      change.myStationId = req->stationId();
      change.myRoles = req->roles();
      myPendingControlChanges.push_back(change);
   }
 
   virtual void updatePlayerControlled(const SetVreControlledContent& change)
   {
      std::vector<std::string> keys = change.myRoles;
 
      if (change.myControlled)
      {
         // unique identifier for each instance of VRE
         DtString thisStation = change.myStationId;
         if (thisStation.isEmpty())
         {
            LOG_WARN("VRESIM")
               << "VRE set role controlled request has blank station id. Unable to identify controlling station."
               << std::endl;
            thisStation = "UNKNOWN";
         }
         // Surround the id with delimiting marks, since the id is an int,
         // to avoid the possibility that one int will be found within another
         thisStation = "{" + thisStation + "}";
 
         for (int i = 0; i < keys.size(); i++)
         {
            std::string stations = this->entity()
                                      ->getStateComponent<makVrf::DtVrfStateComponent>()
                                      ->extendedData("role-" + keys[i])
                                      .stdString();
 
            // Check if this station is already in the list
            if (stations.find(thisStation) == -1)
            {
               // It isn't, so append it to the list
               this->entity()->getNextFrameStateComponent<makVrf::DtVrfStateComponent>()->setExtendedData(
                  "role-" + keys[i], stations + thisStation);
            }
         }
      }
      else
      {
         DtString thisStation = change.myStationId;
         if (thisStation.isEmpty())
         {
            LOG_WARN("VRESIM")
               << "VRE set role controlled request has blank station id. Unable to identify controlling station."
               << std::endl;
            thisStation = "UNKNOWN";
         }
         thisStation = "{" + thisStation + "}";
 
         for (int i = 0; i < keys.size(); i++)
         {
            std::string stations = this->entity()
                                      ->getStateComponent<makVrf::DtVrfStateComponent>()
                                      ->extendedData("role-" + keys[i])
                                      .stdString();
            // only disable this role if we are the one occupying it
            int foundAt = stations.find(thisStation);
            if (foundAt > -1)
            {
               // Remove this station from the list
               std::string pre = stations.substr(0, foundAt);
               std::string post = stations.substr(foundAt + thisStation.length());
               stations = pre + post;
 
               if (stations.empty())
               {
                  this->entity()->getNextFrameStateComponent<makVrf::DtVrfStateComponent>()->removeExtendedData(
                     "role-" + keys[i]);
               }
               else
               {
                  this->entity()->getNextFrameStateComponent<makVrf::DtVrfStateComponent>()->setExtendedData(
                     "role-" + keys[i], stations);
               }
            }
         }
      }
   }
 
   //! \brief Initializes the controller before the first tick
   //!
   //! Performs initialization that must happen before the first tick but after
   //! the component is fully constructed. Clears any existing role assignments
   //! by removing all extended data entries with keys starting with "role-".
   //! Then calls the base class preFirstTickInit().
   virtual void preFirstTickInit()
   {
      // Search map for any entries with a key starting with "role-" and remove them
      for (const std::pair<DtString, DtString>& data :
         this->entity()->getStateComponent<makVrf::DtVrfStateComponent>()->extendedData())
      {
         if (data.first.findString("role-") == 0)
         {
            this->entity()->getNextFrameStateComponent<makVrf::DtVrfStateComponent>()->removeExtendedData(data.first);
         }
      }
 
      DtVreSimComponent<SetControllerBase>::preFirstTickInit();
   }
 
   //! \brief Updates the controller state each simulation frame
   //!
   //! Handles different behavior based on whether the entity is player controlled.
   //! If not player controlled, operates normally under CGF control. If player controlled,
   //! publishes detailed resource information in the entity's extended data for
   //! use by the VR-Engage interface.
   virtual void tick()
   {
      // Handle one control change each tick.
      if (!myPendingControlChanges.empty())
      {
         SetVreControlledContent change = myPendingControlChanges.front();
         myPendingControlChanges.pop_front();
         updatePlayerControlled(change);
      }
 
      if (!this->isPlayerControlled())
      {
         // The CGF is controlling the turret, so operate normally under CGF control.
         DtVreSimComponent<SetControllerBase>::tick();
      }
   }
 
   //! \brief Processes altitude setting messages with enhanced terrain handling
   //! \param msg The simulation message containing altitude setting information
   //!
   //! Overrides the base method to correctly handle setting altitude of 0 m above terrain.
   //! Provides special handling for altitude values of 0, which are interpreted as
   //! "place the entity directly on the terrain" rather than "place at 0 MSL".
   //! Also handles terrain clamping appropriately.
   virtual void processSetAltitude(DtSimMessage* msg)
   {
      DtSetDataRequestMessage* drMsg = (DtSetDataRequestMessage*)msg;
      DtSetAltitudeRequest* req = (DtSetAltitudeRequest*)drMsg->setDataRequest();
 
      // Set the actual altitude
      DtVrfObjectStateRepository* vrfObjSR = this->localStateRepository();
      if (!vrfObjSR)
      {
         return;
      }
 
      double altitude = req->altitude();
      bool clamp = false;
      DtTerrainIntersectStatus status;
 
      double terrainHeight = this->physicalWorld()->terrainHeight(this->entity()->nextFrameLocalPosition(), status,
         DtTerrainIntersectOptions::nonBlocking().withMask(
            this->entity()->parameters()->movementTerrainCategoryMask()));
 
      if (status.dataAvailable())
      {
         if (altitude == 0)
         {
            clamp = true;
 
            if (status.dataAvailable())
            {
               altitude = terrainHeight;
            }
         }
         else
         {
            if (status.dataAvailable())
            {
               altitude += terrainHeight;
            }
         }
      }
      else
      {
         // If the MSL is close to the terrain, clamp it
         if (status.dataAvailable())
         {
            if (DtALMOST(terrainHeight, altitude, 1.0))
            {
               clamp = true;
            }
         }
      }
 
      DtGeodeticCoord newGeodeticPosition;
      newGeodeticPosition.setGeocentric(this->entity()->nextFrameWorldPosition());
      newGeodeticPosition.setAlt(altitude);
      this->objectConsoleDebug(this->type()) << "Setting altitude: " << altitude << std::endl;
 
      DtVector newLocalPosition;
      this->terrainAttachedTo()->coordinateSystem()->dis2local(newGeodeticPosition.geocentric(), newLocalPosition);
 
      // If we are setting altitude we should certainly not be clamping to ground!
      DtVrfMovingObjectStateRepository* movingSR = vrfObjSR->as<DtVrfMovingObjectStateRepository>();
 
      if (movingSR)
      {
         movingSR->setAmClampedToGround(clamp);
      }
 
      this->entity()->internalState()->place(newLocalPosition);
 
      // this might work better if there is a good way to get a local topo dcm at MSL
      //    DtDcm topoToLocalDcm;
      //    DtVector localPosition = vrfObjSR->vrfKinematicState()->localPosition();
      //    // fixme might have to set localPositio to zero height here
      //    terrainAttachedTo()->coordinateSystem()->topoToLocal(localPosition, topoToLocalDcm);
      //    DtCoordTransform transform(localPosition, topoToLocalDcm);
      //    transform.coordTrans(DtVector(0, 0, -req->altitude()), localPosition);
      //
      //    objectConsoleDebug(type()) << "Setting altitude: " << req->altitude() << std::endl;
      //    this->entity()->place(localPosition);
   }
 
   //! \brief Factory method to create a new instance of this component
   //! \param name The name for the new component
   //! \param owner The local object that will own this component
   //! \param simManager The simulation services manager
   //! \param desc Optional component descriptor
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //! \return Pointer to the newly created component
   //!
   //! Static factory method used by the component creation system to instantiate
   //! new instances of this component type.
   static DtSimComponent* creator(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0)
   {
      return new DtVreSetController<SetControllerBase>(name, owner, simManager, desc, parentRegistry);
   }
 
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization. Here because
   //! the compiler would generate an unprotected one otherwise.
   DtVreSetController();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtVreSetController(const DtVreSetController& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtVreSetController& operator=(const DtVreSetController& orig);
 
protected:
   //! \brief Flag indicating if a resource warning has been logged
   //!
   //! Tracks whether a warning about exceeding the maximum resource string size
   //! has already been logged, to prevent spamming the log with the same warning.
   bool myWarnedAboutResource;
 
   std::list<SetVreControlledContent> myPendingControlChanges;
};
} // namespace makVre