pilotSimLogic.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file pilotSimLogic.h
//! \brief Defines DtPilotSimLogic for managing aircraft simulation control logic
//! \ingroup vrePilotFrontend
 
#pragma once
 
#include <vrePlayerStation/entityControlLogic.h>
#include <vrePlayerStation/entityHelper.h>
#include <vreMessageManager/vreMessage.h>
#include <vreUtil/coordConverter.h>
 
#include <matrix/vlVector.h>
 
#include <string>
#include <vector>
 
#include <vrePilotFrontend/export.h>
 
namespace makVrv
{
//! \brief Forward declaration of the display element class
class DtDe;
 
//! \brief Forward declaration of the scene object class
class DtSceneObject;
 
//! \brief Forward declaration of the observer class
class DtObserver;
}; // namespace makVrv
 
namespace makAudio
{
//! \brief Forward declaration of the sound class
class DtSound;
} // namespace makAudio
 
namespace makVre
{
//! \brief Forward declaration of the flight controls input logic class
class DtFlightControlsInputLogic;
 
//! \brief Forward declaration of the pilot instruments input logic class
class DtPilotInstrumentsInputLogic;
 
namespace PilotSimLogicConfig
{
//! \ingroup RoleConfigParams
//! \defgroup PilotSimLogicRoleParams Pilot Simulation Logic Role Parameters
//! \roleInherits{EntityControlLogicRoleParams}
//! Configuration Options for pilotSimLogic role.
//! @{
 
//! \vreRoleParam{lowAltitudeThreshold,double,500.0,pilotSimLogic,Altitude threshold in feet below which low altitude warning is triggered.}
constexpr const char* lowAltitudeThreshold = "lowAltitudeThreshold";
 
//! \vreRoleParam{rwrConfig,table,{},pilotSimLogic,Configuration table for radar warning receiver (RWR) settings and sound mappings.}
constexpr const char* rwrConfig = "rwrConfig";
 
//! \vreRoleParam{sensorName,string,"Gimbaled Sensor",pilotSimLogic,Name of the primary sensor system for this aircraft.}
constexpr const char* sensorName = "sensorName";
 
//! \vreRoleParam{stallThreshold,double,100.0,pilotSimLogic,Airspeed threshold in knots below which stall warning is triggered.}
constexpr const char* stallThreshold = "stallThreshold";
 
//! \vreRoleParam{useHelicopterControls,bool,false,pilotSimLogic,Whether to use helicopter control scheme instead of fixed-wing controls.}
constexpr const char* useHelicopterControls = "useHelicopterControls";
 
//! \vreRoleParam{useRTD,bool,false,pilotSimLogic,Whether to use real-time dynamics for flight simulation.}
constexpr const char* useRTD = "useRTD";
 
//! @}
} // namespace PilotSimLogicConfig
 
//! \brief Type identifier for DtPilotSimLogic component
constexpr const char* DtPilotSimLogicType = "DtPilotSimLogic";
 
//! \brief Simulation logic component for the pilot role
//!
//! DtPilotSimLogic manages aircraft simulation behavior including flight controls,
//! weapons systems, sensors, and aircraft-specific functionality. It provides methods
//! for controlling aircraft systems and responding to simulation events while acting
//! as the main control logic for pilot entities.
class PILOT_DLL DtPilotSimLogic : public DtEntityControlLogic
{
public:
   //! \brief Default constructor
   DtPilotSimLogic();
 
   //! \brief Virtual destructor
   virtual ~DtPilotSimLogic() override;
 
   //! \brief Initializes the pilot simulation logic component
   //! \param player Pointer to the player station
   //! \param config Configuration settings for initialization
   //! \return True if initialization was successful, false otherwise
   virtual bool initialize(DtPlayerStation* player, DtInitTable& config) override;
 
   //! \brief Updates simulation state for the current frame
   //! \param dt Delta time since the last frame in seconds
   virtual void tick(double dt) override;
 
   //! \brief Cleans up resources when the component is being shut down
   virtual void shutdown() override;
 
   //! \brief Returns the component type identifier
   //! \return The component type string
   virtual const char* type() const override;
 
   //! \brief Sends a joystick control message to the simulation
   //! \param functionGroup Function group name for the joystick control
   //! \param function Function name for the joystick control
   //! \param val Input value for the function
   //! \param delay Optional delay in seconds before the message is processed
   virtual void sendJoystickMessage(
      const std::string& functionGroup, const std::string& function, double val, double delay = 0);
 
   //! \brief Checks if real-time dynamics are enabled
   //! \return True if real-time dynamics are enabled, false otherwise
   virtual bool useRTD();
 
   //! \brief Gets a reference to the flight controls input logic
   //! \return Reference to the flight controls input logic component
   virtual DtFlightControlsInputLogic& flightControls();
 
   //! \brief Gets a reference to the instrument controls input logic
   //! \return Reference to the instrument controls input logic component
   virtual DtPilotInstrumentsInputLogic& instrumentControls();
 
   //! \brief Checks if the aircraft is a helicopter
   //! \return True if the aircraft is a helicopter, false if it's fixed-wing
   virtual bool isHelo() { return myHelo; };
 
   //! \brief Checks if the cargo door is open
   //! \return True if the cargo door is open, false otherwise
   virtual bool isCargoDoorOpen();
 
   //! \brief Opens the cargo door
   virtual void openCargoDoor();
 
   //! \brief Closes the cargo door
   virtual void closeCargoDoor();
 
   //! \brief Checks if the sliding door is open
   //! \return True if the sliding door is open, false otherwise
   virtual bool isSlidingDoorOpen();
 
   //! \brief Opens the sliding door
   virtual void openSlidingDoor();
 
   //! \brief Closes the sliding door
   virtual void closeSlidingDoor();
 
   //! \brief Checks if the sling load door is open
   //! \return True if the sling load door is open, false otherwise
   virtual bool isSlingLoadDoorOpen();
 
   //! \brief Opens the sling load door
   virtual void openSlingLoadDoor();
 
   //! \brief Closes the sling load door
   virtual void closeSlingLoadDoor();
 
   //! \brief Checks if the landing gear is down
   //! \return True if the landing gear is down, false if it's up
   virtual bool isLandingGearDown();
 
   //! \brief Requests a Synthetic Aperture Radar (SAR) image
   virtual void requestSarImage();
 
   //! \brief Commands the gimbal sensor to track a laser code
   //! \param laserCode The laser code to track
   //! \param continuousTrack Flag indicating whether to continuously track the code
   virtual void gimbalTrackLaserCode(int laserCode, bool continuousTrack);
 
   //! \brief Commands the gimbal sensor to track an MGRS coordinate
   //! \param mgrsCoord MGRS coordinate string to track
   virtual void gimbalTrackMgrsCoord(const std::string& mgrsCoord);
   //! \brief Cycles to the next gimbal sensor mode
   //!
   //! Cycles through available sensor modes which typically include IR (infrared),
   //! NVG (night vision), and OTW (out-the-window/normal vision).
   virtual void cycleGimbalSensorMode();
 
   //! \brief Sets the autopilot mode
   //! \param newMode New autopilot mode to set ("OFF", "PATH", "ALT/HDG/SPD", "ALT", "HDG", "SPD")
   //! \param stayDisabledIfOff If true and the mode is set to "OFF", autopilot will remain off when toggled
   //!
   //! Pass an empty string to cycle to the next setting.
   virtual void setAutopilot(const std::string& newMode, bool stayDisabledIfOff = false);
 
   //! \brief Toggles the autopilot on/off
   virtual void toggleAutopilot();
 
   //! \brief Resets the aircraft in its current location
   //! \param val Input value, typically 1.0 for activation
   //!
   //! Overloaded to handle special case when the aircraft is on the ground
   virtual void resetInPlace(float val = 1) override;
 
   //! \brief Sets the flap position
   //! \param flap Flap position index to set
   virtual void setFlap(int flap);
 
   //! \brief Sets the autopilot mode extended data
   //! \param value Mode value as a string
   virtual void setAutopilotMode(const std::string& value);
 
   //! \brief Sets the autopilot heading extended data
   //! \param value Heading value as a string
   virtual void setAutopilotHeading(const std::string& value);
 
   //! \brief Sets the autopilot altitude extended data
   //! \param value Altitude value as a string
   virtual void setAutopilotAltitude(const std::string& value);
 
   //! \brief Sets the autopilot speed extended data
   //! \param value Speed value as a string
   virtual void setAutopilotSpeed(const std::string& value);
 
   //! \brief Sets the autopilot route extended data
   //! \param value Route value as a string
   virtual void setAutopilotRoute(const std::string& value);
 
   //! \brief Suppresses warning messages temporarily
   //!
   //! Suppresses audio and visual warnings for a configured duration
   virtual void suppressWarnings();
 
   //! \name Joystick Function Processing
   //! Methods for processing joystick inputs. The input value range is typically 0.0 to 1.0
   //! and can represent either an axis value or a button value.
   //! @{
 
   //! \brief Handles joystick trigger input
   //! \param val Input value, typically 1.0 for activation
   virtual void trigger(double val);
 
   //! \brief Toggles between first-person and third-person view modes
   //! \param val Input value, typically 1.0 for activation
   virtual void toggleObserverAttachMode(double val);
 
   //! \brief Toggles the laser designator on/off
   virtual void toggleLasingState();
 
   //! \brief Sets the laser designator code
   //! \param val Laser code to set
   virtual void setLaserCode(int val);
 
   //! \brief Sets the target as the bullseye reference point
   //! \param target Entity identifier of the target to set as bullseye
   virtual void setBullseye(const DtEntityIdentifier& target);
 
   //! \brief Commands the gimbal sensor to track a radar-detected entity
   //!
   //! Directs the gimbal sensor to slew to and track the currently designated radar target
   virtual void gimbalTrackDesignatedRadarTrack();
 
   //! \brief Structure containing countermeasures launch parameters
   struct CmLaunchParameters
   {
   public:
      int numToFire;       //!< Number of countermeasures to fire
      double fireInterval; //!< Time interval between successive launches in seconds
      DtEntityType cmType; //!< Entity type of the countermeasures to launch
   };
 
   //! \brief Gets the launch parameters for a specific countermeasure type
   //! \param countermeasuresName Name of the countermeasures type
   //! \return Launch parameters for the specified countermeasures
   virtual CmLaunchParameters countermeasuresLaunchParameters(const std::string& countermeasuresName);
 
   //! \brief Clears the cached location the gimbaled sensor is pointing at
   virtual void clearTrackingLocation();
 
   //! \brief Toggles between true north and magnetic north reference
   //! \param val Input value, typically 1.0 for activation
   virtual void toggleNorthReference(double val);
 
   //! @}
 
protected:
   //! \name Message Handler Methods
   //! Methods for handling various message types from the message manager
   //! @{
 
   //! \brief Handles simulation state messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   //!
   //! Updates state attributes based on ownship simulation state.
   virtual DtVreMessageResult handleSimState(DtVreMessage* msg) override;
 
   //! \brief Handles cockpit initialized messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   //!
   //! Updates the master warning enabled/disabled state on cockpit initialization.
   virtual DtVreMessageResult handleCockpitInitialized(DtVreMessage* msg);
 
   //! \brief Handles RWR catalog request messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   //!
   //! Updates the Radar Warning Receiver with the configured catalog when the RWR is initialized.
   virtual DtVreMessageResult handleRwrCatalogRequest(DtVreMessage* msg);
 
   //! \brief Handles RWR play sound messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   //!
   //! Plays the specified RWR sound or stops all sounds when "Stop" is specified.
   virtual DtVreMessageResult handleRwrPlaySound(DtVreMessage* msg);
 
   //! \brief Handles entity state string messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   //!
   //! Updates the "selectedWeaponLabel" state attribute when the "SelectedWeapon" state property is updated.
   virtual DtVreMessageResult handleEntityStateStringMessage(DtVreMessage* msg);
 
   //! \brief Handles RWR sounds enabled messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   //!
   //! Sets the "rwrSoundsEnabled" state attribute.
   virtual DtVreMessageResult handleSetRwrSoundsEnabledMessage(DtVreMessage* msg);
 
   //! \brief Handles gimbal cycle sensor mode messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   //!
   //! If this message is intended for this entity, cycles the gimbal view by calling
   //! cycleGimbalSensorMode(). This causes the gimbal view of the Multi-Functional
   //! Display to cycle to the next sensor view (typically IR, NVG, and Out-the-Window).
   //! This message can be received from a GL Studio mouse button click or controller input.
   virtual DtVreMessageResult handleGimbalCycleSensorModeMessage(DtVreMessage* msg);
   //! @}
 
   //! \brief Handles cycle selected weapon messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   //!
   //! If this message is intended for this entity, cycles the selected weapon.
   //! This message is received from an MFD button click when the Weapons and Stores panel
   //! is activated.
   virtual DtVreMessageResult handleCycleSelectedWeaponMessage(DtVreMessage* msg);
 
   //! \brief Handles toggle auto countermeasures messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   //!
   //! If this message is intended for this entity, toggles automatic countermeasures on/off.
   //! This message is received from an MFD button click when the Weapons and Stores panel
   //! is activated.
   virtual DtVreMessageResult handleToggleAutoCountermeasuresMessage(DtVreMessage* msg);
 
   //! \brief Handles designated targets update messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   //!
   //! Handles radar target selection messages, which are received from a radar 'z' button
   //! click when in radar MFD or cursor select from joystick. Allows the gimbal sensor to
   //! track a radar-detected entity.
   virtual DtVreMessageResult handleDesignatedTargetsUpdate(DtVreMessage* msg);
 
   //! \brief Handles window created messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   //!
   //! Caches the window and channel name for the gimbaled sensor when windows are created.
   virtual DtVreMessageResult handleWindowCreated(DtVreMessage* msg);
 
   //! \brief Adds a sound to the RWR sound system
   //! \param key Identifier key for the sound
   //! \param soundFile Path to the sound file
   //! \param pitch Pitch adjustment for the sound
   //! \param volume Volume level for the sound
   //! \param repeatSound Whether the sound should loop
   virtual void addRwrSound(
      const std::string& key, const std::string& soundFile, double pitch, double volume, bool repeatSound);
 
   //! \brief Plays a specific RWR sound
   //! \param key Identifier key of the sound to play
   virtual void playRwrSound(const std::string& key);
 
   //! \brief Stops all currently playing RWR sounds
   virtual void stopRwrSounds();
 
   //! \brief Stops the laser designator
   //!
   //! Deactivates the laser designator and stops lasing the current location
   virtual void stopLasingLocation();
 
   //! \brief Starts the laser designator
   //!
   //! Activates the laser designator and begins lasing the current target location
   virtual void startLasingLocation();
 
protected:
   //! \brief Flag indicating if real-time dynamics are enabled
   bool myUseRTD;
 
   //! \brief Pointer to the flight controls input logic component
   DtFlightControlsInputLogic* myFlightControlsInputLogic;
 
   //! \brief Pointer to the instruments input logic component
   DtPilotInstrumentsInputLogic* myInstrumentsInputLogic;
 
   //! \brief Current observer attachment type
   int myAttachType;
 
   //! \brief Offset vector for observer attachment
   DtVector myAttachOffset;
 
   //! \brief Orientation for observer attachment
   DtTaitBryan myAttachOrientation;
 
   //! \brief Map of RWR sounds indexed by sound key
   //!
   //! Sounds to play for various RWR events, such as when a new contact is added.
   std::map<std::string, makAudio::DtSound*> myRwrSoundMap;
 
   //! \brief Cached RWR configuration table
   //!
   //! Caches the Radar Warning Receiver catalog to send to the RWR once it's initialized.
   DtInitTable myRwrConfig;
 
   //! \brief Flag indicating if the aircraft is a helicopter
   bool myHelo;
 
   //! \brief Previously set autopilot mode
   std::string myCachedAutopilotMode;
 
   //! \brief Altitude threshold for low altitude warnings in meters
   double myLowAltitudeThreshold;
 
   //! \brief Airspeed threshold for stall warnings in meters per second
   double myStallThreshold;
 
   //! \brief Time remaining for warning suppression in seconds
   double myWarningsSuppressed;
 
   //! \brief Name of the window containing the gimbal display
   std::string myGimbalWindowName;
 
   //! \brief Name of the channel containing the gimbal display
   std::string myGimbalChannelName;
 
   //! \brief Name of the current sensor
   std::string mySensorName;
 
   //! \brief Vector of available gimbal sensor modes
   //!
   //! The different gimbal sensor modes (IR, NVG, Out-the-Window).
   //! The first element of the vector is the current mode.
   //! When cycling modes, the vector elements are rotated.
   //! - IR: infrared sensor view
   //! - NVG: night vision sensor view
   //! - Out-the-Window: regular view without special effects
   std::vector<std::string> myGimbalSensorModes;
 
   //! \brief Pointer to the observer for getting position and orientation
   //!
   //! Used in gun fire to get observer X,Y,Z & H,P,R
   makVrv::DtObserver* myObserver;
 
   //! \brief Entity identifier of the currently designated radar target
   DtEntityIdentifier myDesginatedRadarTarget;
 
   //! \brief Map of countermeasures launch parameters indexed by name
   std::map<std::string, CmLaunchParameters> myCmLaunchParameters;
};
} // namespace makVre