rotaryWingJoyFlightController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file rotaryWingJoyFlightController.h
//! \ingroup vreVrfmodel
//! \brief Controller for joystick-based rotary-wing aircraft flight control
//!
//! This file defines the DtRotaryWingJoyFlightController class which provides
//! joystick control functionality for rotary-wing aircraft. It extends the base
//! rotary wing pilot controller to map joystick inputs to helicopter flight controls.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include <vrfmodel/rotaryWingPilotController.h>
#include <vrfmodel/joystickControllerInterface.h>
 
class DtString;
class DtSimulationServices;
class DtJoyDeviceControllerDescriptor;
class DtJoyDevice;
 
namespace makVre
{
//! \brief Type identifier for the rotary wing joystick flight controller component
const char DtRotaryWingJoyFlightControllerType[] = "rotary-wing-joy-flight-controller";
 
//! \brief Controller for joystick-based rotary-wing aircraft flight control
//!
//! DtRotaryWingJoyFlightController extends the base rotary wing pilot controller
//! to provide joystick control functionality for helicopters and other rotary-wing
//! aircraft. It translates joystick inputs into appropriate control commands for
//! cyclic, collective, and anti-torque controls, managing the complex flight
//! dynamics of rotary-wing vehicles.
//!
//! The controller includes stabilization functionality with configurable gains
//! to assist pilot control while still allowing for realistic helicopter flight
//! characteristics.
//!
//! Uses Descriptor Type: DtRotaryWingPilotDescriptor
class VREVRFMODEL_DLL DtRotaryWingJoyFlightController : public DtRotaryWingPilotController,
                                                        public DtJoystickControllerInterface
{
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 rotary wing joystick flight controller component with the specified parameters.
   //! Initializes control gains and joystick input mappings for helicopter flight control.
   DtRotaryWingJoyFlightController(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the rotary wing joystick flight controller component.
   virtual ~DtRotaryWingJoyFlightController() override;
 
   //! \brief Initializes the controller
   //! \return True if initialization was successful, false otherwise
   //!
   //! Initializes the rotary wing joystick flight controller, setting up control
   //! gains and registering with the joystick system. Called during component creation.
   virtual bool init() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtRotaryWingJoyFlightControllerType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() const 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);
 
protected:
   //! \brief Calculates stabilizing control gains for rotary wing flight
   //! \param manuverConst Maneuverability constant affecting control responsiveness
   //! \param riseTime Time to desired rise in response to control inputs
   //! \param velGain Output parameter for calculated velocity gain
   //! \param oriGain Output parameter for calculated orientation gain
   //!
   //! Calculates stabilizing gains using the input parameters and internal
   //! configuration. These gains are used to establish the proper balance between
   //! control responsiveness and stability for the rotary wing aircraft.
   virtual void calculateGains(const DtReal manuverConst, const DtReal riseTime, DtReal& velGain, DtReal& oriGain);
 
   //! \brief Processes joystick input and sets corresponding port values
   //! \param functionGroup The function group identifier for the input
   //! \param function The specific function name for the input
   //! \param value The input value (typically in range [-1.0, 1.0])
   //! \param repeat Flag indicating whether the function should repeat
   //!
   //! Handles joystick input by translating joystick function calls into
   //! appropriate helicopter control values. Maps joystick axes and buttons
   //! to cyclic, collective, and anti-torque controls for rotary wing flight.
   virtual void calcAndSetPortValues(
      const DtString& functionGroup, const DtString& function, double value, bool repeat) override;
   //! \brief Handles joystick connection events
   //!
   //! Required by the DtJoystickControllerInterface. Called when a joystick
   //! is connected to the system. Sets up initial joystick mappings and
   //! prepares the controller to receive joystick inputs.
   virtual void joystickConnected() override;
   //! \brief Handles joystick disconnection events
   //!
   //! Required by the DtJoystickControllerInterface. Called when a joystick
   //! is disconnected from the system. Ensures the controller gracefully
   //! handles the loss of joystick input.
   virtual void joystickDisconnected() override;
 
protected:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is protected and not implemented to prevent
   //! creation of instances without proper initialization.
   DtRotaryWingJoyFlightController();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is protected and not implemented to prevent
   //! copy construction.
   DtRotaryWingJoyFlightController(const DtRotaryWingJoyFlightController& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is protected and not implemented to prevent assignment.
   DtRotaryWingJoyFlightController& operator=(const DtRotaryWingJoyFlightController& orig);
 
protected:
   //! \brief Feedback gain for the pitch angular velocity control
   //!
   //! Controls the responsiveness of the pitch rate to joystick inputs.
   //! Higher values result in faster pitch rate changes.
   DtReal myPitchVelGain;
 
   //! \brief Feedback gain for the pitch orientation control
   //!
   //! Controls the responsiveness of the pitch angle to joystick inputs.
   //! Higher values result in more direct pitch angle control.
   DtReal myPitchOriGain;
 
   //! \brief Feedback gain for the roll angular velocity control
   //!
   //! Controls the responsiveness of the roll rate to joystick inputs.
   //! Higher values result in faster roll rate changes.
   DtReal myRollVelGain;
 
   //! \brief Feedback gain for the roll orientation control
   //!
   //! Controls the responsiveness of the roll angle to joystick inputs.
   //! Higher values result in more direct roll angle control.
   DtReal myRollOriGain;
 
   //! \brief Feedback gain for the yaw angular velocity control
   //!
   //! Controls the responsiveness of the yaw rate to joystick inputs.
   //! Higher values result in faster yaw rate changes.
   DtReal myYawVelGain;
 
   //! \brief Feedback gain for the yaw orientation control
   //!
   //! Controls the responsiveness of the yaw angle to joystick inputs.
   //! Higher values result in more direct yaw angle control.
   DtReal myYawOriGain;
};
} // namespace makVre