vreHumanFollowController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreHumanFollowController.h
//! \ingroup vreVrfmodel
//! \brief Controller for human entity following behavior
//!
//! This file defines the DtVreHumanFollowController class which models the behavior
//! of human entities when following other entities. It dynamically recalculates
//! movement destinations to maintain proper following positioning.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include <vrfmodel/humanFollowController.h>
#include "vreVrfModel/vreSimComponent.h"
 
class DtStringOutputPort;
 
namespace makVre
{
//! \brief Type identifier for the VRE human follow controller component
const char DtVreHumanFollowControllerType[] = "vre-human-follow-controller";
 
//! \brief Controller for human entity following behavior
//!
//! DtVreHumanFollowController models the behavior of human entities when following
//! other entities. During each simulation frame, the destination to which the entity
//! moves is dynamically recalculated to be in the proper position with respect to the
//! followed entity. This allows humans to maintain formation, follow leaders, or
//! maintain specific offset positions relative to other entities.
//!
//! Uses Descriptor Type: DtHumanFollowControllerDescriptor
class VREVRFMODEL_DLL DtVreHumanFollowController : public DtVreSimComponent<DtHumanFollowController>
{
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 follow controller component with the specified parameters.
   DtVreHumanFollowController(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the human follow controller component.
   virtual ~DtVreHumanFollowController() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtVreHumanFollowControllerType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() const override;
 
   //! \brief Updates the controller state each simulation frame
   //!
   //! Updates the output port with the current follow target from the PSR (Process
   //! State Repository). During each simulation frame, this method recalculates
   //! the destination position relative to the followed entity and updates the
   //! entity's movement accordingly.
   virtual void tick() override;
 
   //! \brief Creates the input and output ports for the controller
   //! \return True if ports are successfully created, false otherwise
   //!
   //! Creates additional port for the follow target point. This port is used to
   //! output the current target entity being followed, allowing other components
   //! to access this information.
   virtual bool createPorts() 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);
 
private:
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtVreHumanFollowController(const DtVreHumanFollowController& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtVreHumanFollowController& operator=(const DtVreHumanFollowController& orig);
 
protected:
   //! \brief Output port for the current follow target entity name
   //!
   //! This port outputs the name of the entity currently being followed.
   //! Other components can connect to this port to receive updates when
   //! the follow target changes.
   DtStringOutputPort* myFollowTargetOutputPort;
 
   //! \brief ID for the disembark subtask
   //!
   //! Stores the subtask ID used for disembarkation operations when
   //! a followed entity is being disembarked from another entity.
   int myDisembarkSubtaskId;
};
 
} // namespace makVre