controlSurfacesActuator.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file controlSurfacesActuator.h
//! \ingroup vreVrfmodel
//! \brief Actuator for aircraft control surfaces
//!
//! This file defines the DtControlSurfacesActuator class which manages the articulated
//! parts for fixed wing control surfaces (rudder, ailerons, elevators) and flaps based on
//! incoming port data. It translates control inputs into appropriate control surface
//! deflections.
 
#pragma once
 
#include <vreVrfmodel/export.h>
#include <vreVrfmodel/vreSimComponent.h>
 
#include <vreMessageManager/vreMessage.h>
 
#include <vrfobjcore/actuatorComponent.h>
 
class DtString;
class DtSimulationServices;
 
class DtControlSurfacesActuatorDescriptor;
class DtAnalogInputPort;
class DtBooleanInputPort;
 
namespace makVre
{
//! \brief Type identifier for the control surfaces actuator component
const char DtControlSurfacesActuatorType[] = "control-surfaces-actuator";
 
//! \brief Actuator component for aircraft flight control surfaces
//!
//! DtControlSurfacesActuator manages the articulated parts for fixed wing
//! flight control surfaces such as rudder, ailerons, elevators, and flaps.
//! It receives control inputs through input ports and applies the appropriate
//! deflection values to the corresponding articulated parts.
//!
//! Uses Descriptor Type: DtActuatorComponentDescriptor
class VREVRFMODEL_DLL DtControlSurfacesActuator : public DtVreSimComponent<DtActuatorComponent>
{
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 Optional component descriptor
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //!
   //! Creates a new control surfaces actuator component with the specified parameters.
   DtControlSurfacesActuator(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the control surfaces actuator component.
   virtual ~DtControlSurfacesActuator() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtControlSurfacesActuatorType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() const override;
 
   // virtual bool init() override;
 
   //! \brief Performs post-component-addition initialization
   //! \return True if initialization is successful, false otherwise
   //!
   //! Gets and caches references to the articulated part repositories for
   //! each control surface after all components have been added.
   virtual bool postAddComponentsInit() override;
 
   //! \brief Updates control surface positions each simulation frame
   //!
   //! Reads current input port values and applies the appropriate deflection
   //! to each control surface articulated part. When player control is lost,
   //! it will run one additional tick to reset surfaces to neutral positions.
   virtual void tick() 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 Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtControlSurfacesActuator();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtControlSurfacesActuator(const DtControlSurfacesActuator& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtControlSurfacesActuator& operator=(const DtControlSurfacesActuator& orig);
 
protected:
   //! \brief Creates input ports for control surfaces
   //! \return True if ports were created successfully, false otherwise
   //!
   //! Creates the input ports for each defined control surface and
   //! adds them to the control surfaces port group.
   virtual bool createPorts() override;
 
   //! \brief Creates port groups for organizing input ports
   //! \return True if port groups were created successfully, false otherwise
   //!
   //! Creates a port group called "control-surfaces" to organize
   //! all control surface input ports.
   virtual bool createPortGroups() override;
 
   //! \brief Associates an input port with the corresponding art part repository
   //!
   //! This structure maintains the relationship between an input port that
   //! receives control commands and the articulated part that should be
   //! manipulated based on those commands.
   struct PortData
   {
      //! \brief Default constructor
      //!
      //! Initializes pointers to null
      PortData()
         : myInput(0)
         , myPartRep(0)
      {
      }
 
      //! \brief Pointer to the analog input port for this control surface
      DtAnalogInputPort* myInput;
 
      //! \brief Pointer to the articulated part state repository for this control surface
      makVrf::DtArticulatedPartStateRepository* myPartRep;
   };
 
   //! \brief Map of control surface names to their port and articulated part data
   //!
   //! Maps each control surface name (e.g., "rudder", "aileron") to its
   //! corresponding PortData structure containing input port and art part references.
   std::map<std::string, PortData> myPorts;
 
   //! \brief Port group for control surface inputs
   //!
   //! Groups all control surface input ports under the "control-surfaces" group
   //! for easier organization and access.
   DtInputPortGroup* myControlSurfacesInputGroup;
 
   //! \brief Flag indicating if this entity is currently player-controlled
   //!
   //! Tracks whether the entity is currently under player control. When control is lost,
   //! this allows the actuator to tick one more time to reset control surfaces to
   //! neutral positions.
   bool myPlayerControlled;
};
 
} // namespace makVre