vreHumanSetController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreHumanSetController.h
//! \ingroup vreVrfmodel
//! \brief Controller for managing sets of human entities
//!
//! This file defines the DtVreHumanSetController class which extends the base set
//! controller for human entities. It handles altitude and speed control differently
//! for player-controlled human entities versus AI-controlled ones.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include "vreVrfmodel/vreSetController.h"
 
#include <vrfmodel/humanSetController.h>
 
namespace makVre
{
//! \brief Type identifier for the VRE human set controller component
const char DtVreHumanSetControllerType[] = "vre-human-set-controller";
 
//! \brief Controller for managing sets of human entities
//!
//! DtVreHumanSetController extends the base set controller functionality for human entities.
//! It handles altitude and speed control differently for player-controlled versus AI-controlled
//! entities. The controller provides specialized handling for human-specific behaviors such as
//! speed limitations, embarkation roles, and coordinated movement of human groups.
 
class VREVRFMODEL_DLL DtVreHumanSetController : public DtVreSetController<DtHumanSetController>
{
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 human set controller component with the specified parameters.
   DtVreHumanSetController(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the human set controller component.
   virtual ~DtVreHumanSetController() override;
 
   //! \brief Callback for embarkation role messages
   //! \param msg The message containing embarkation role information
   //! \param usrData User data pointer, typically pointing to the instance of this class
   //!
   //! Static callback function invoked when an entity's embarkation role changes.
   //! This forwards the message to the instance's processSetEngageEmbarkedRole method.
   static void setEngageEmbarkedRoleCallback(DtSimMessage* msg, void* usrData);
 
   //! \brief Processes embarkation role change messages
   //! \param msg The message containing embarkation role information
   //!
   //! Handles messages that indicate a change in the embarkation role of an entity.
   //! This allows the controller to adjust its behavior based on whether entities
   //! are embarking on vehicles or disembarking from them.
   virtual void processSetEngageEmbarkedRole(DtSimMessage* msg);
 
   //! \brief Processes speed setting messages
   //! \param msg The message containing speed parameters
   //!
   //! Overridden to clamp ordered speed to the maximum speed for AI-controlled entities.
   //! While the VR-Engage human actuator allows speeds greater than the maximum speed for
   //! player-controlled entities to support short-term sprinting, CGF (Computer Generated Forces)
   //! entities are constrained to their maximum sustained speed to maintain realistic behavior.
   virtual void processSetSpeed(DtSimMessage* msg) override;
 
   //! \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);
 
   //! \brief Enables or disables autonomous action processing for the associated entity
   //! \param enable When true autonomous actions are allowed, when false they are suppressed
   //!
   //! Invoked when the embarkation role for the human set changes so that the VR-Forces entity's
   //! frame state reflects the player's engagement status. When a player is embarked and actively
   //! engaged we suppress autonomous actions to avoid conflicts with player control; otherwise the
   //! default autonomous behaviors remain enabled.
   virtual void updateAutonomousActions(bool enable);
 
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization. Declared here because
   //! the compiler would otherwise generate an unprotected one.
   DtVreHumanSetController();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtVreHumanSetController(const DtVreHumanSetController& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtVreHumanSetController& operator=(const DtVreHumanSetController& orig);
 
 
protected:
   //! \brief Sets the radio receiver for simulation messages
   //! \param radio Pointer to the simulation radio for message communication
   //!
   //! Overrides the base class implementation to register interest in specific
   //! message types related to human set control, such as embarkation role changes
   //! and speed commands. This allows the controller to react to these messages.
   virtual void setRadio(DtSimRadio* radio) override;
};
} // namespace makVre