instrumentsInputLogic.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file instrumentsInputLogic.h
//! \brief Defines DtPilotInstrumentsInputLogic for handling aircraft instrument inputs
//! \ingroup vrePilotFrontend
 
#pragma once
 
#include "vrePilotFrontend/export.h"
#include <vrePlayerStation/inputLogic.h>
 
#include "vreMessages/tacCommand.h"
 
namespace makVrv
{
//! \brief Forward declaration of intersectors container class
class DtIntersectorsContainer;
} // namespace makVrv
 
namespace makVre
{
//! \brief Forward declaration of the pilot simulation logic class
class DtPilotSimLogic;
 
//! \brief Input logic for aircraft instrument controls
//!
//! DtPilotInstrumentsInputLogic handles aircraft instrument inputs including
//! radar controls, sensors, display management controls, and other avionics
//! systems. This class translates user input into appropriate actions for
//! aircraft instrumentation systems.
class PILOT_DLL DtPilotInstrumentsInputLogic : public DtInputLogic
{
public:
   //! \brief Constructor
   //! \param simLogic Reference to the pilot simulation logic component
   //! \param configFile Path to the input configuration file
   DtPilotInstrumentsInputLogic(DtPilotSimLogic& simLogic, const std::string& configFile);
 
   //! \brief Virtual destructor
   virtual ~DtPilotInstrumentsInputLogic() override;
 
   //! \brief Initializes the instruments input logic component
   //! \return True if initialization was successful
   virtual void initialize() override;
 
   //! \brief Adds an action handler for instrument controls
   //! \param action Name of the action to handle
   //! \param handler Function to handle the specified action
   virtual void addInstrumentsActionHandler(const std::string& action, DtActionDelegate handler);
 
   //! \brief Toggles radar warning receiver sounds
   //! \param val Input value, defaults to 1.0 for activation
   virtual void toggleRwrSounds(float val = 1);
 
   //! \brief Sends a tactical command to the system
   //! \param command Type of tactical command to send
   //! \param value Value associated with the command
   virtual void sendTacCommand(TacCommandMessage::Command command, float value);
 
   //! \brief Moves the radar cursor upward
   //! \param val Input value, typically 1.0 for activation
   virtual void radarCursorUp(float val);
 
   //! \brief Moves the radar cursor to the right
   //! \param val Input value, typically 1.0 for activation
   virtual void radarCursorRight(float val);
 
   //! \brief Moves the radar cursor downward
   //! \param val Input value, typically 1.0 for activation
   virtual void radarCursorDown(float val);
 
   //! \brief Moves the radar cursor to the left
   //! \param val Input value, typically 1.0 for activation
   virtual void radarCursorLeft(float val);
 
   //! \brief Controls radar cursor horizontal position
   //! \param val Input value in range [-1.0, 1.0]
   virtual void radarCursorX(float val);
 
   //! \brief Controls radar cursor vertical position
   //! \param val Input value in range [-1.0, 1.0]
   virtual void radarCursorY(float val);
 
   //! \brief Selects the target under the radar cursor
   //! \param val Input value, typically 1.0 for activation
   virtual void radarCursorSelect(float val);
 
   //! \brief Deselects the currently selected radar target
   //! \param val Input value, typically 1.0 for activation
   virtual void radarCursorDeselect(float val);
 
   //! \brief Cycles forward through available targets
   //! \param val Input value, typically 1.0 for activation
   virtual void cycleTargetsForward(float val);
 
   //! \brief Cycles backward through available targets
   //! \param val Input value, typically 1.0 for activation
   virtual void cycleTargetsBackward(float val);
 
   //! \brief Clears all selected targets
   //! \param val Input value, typically 1.0 for activation
   virtual void clearTargets(float val);
 
   //! \brief Controls co-pilot's cursor horizontal position
   //! \param val Input value in range [-1.0, 1.0]
   virtual void copCursorX(float val);
 
   //! \brief Controls co-pilot's cursor vertical position
   //! \param val Input value in range [-1.0, 1.0]
   virtual void copCursorY(float val);
 
   //! \brief Controls the Display Management Switch (DMS)
   //! \param direction Direction to push the switch ("up", "down", "left", "right")
   //! \param val Input value, typically 1.0 for activation
   virtual void dms(std::string direction, double val);
 
   //! \brief Activates the Display Management Switch in down direction
   //! \param val Input value, typically 1.0 for activation
   virtual void dmsDown(double val);
 
   //! \brief Activates the Display Management Switch in left direction
   //! \param val Input value, typically 1.0 for activation
   virtual void dmsLeft(double val);
 
   //! \brief Activates the Display Management Switch in right direction
   //! \param val Input value, typically 1.0 for activation
   virtual void dmsRight(double val);
 
   //! \brief Activates the Display Management Switch in up direction
   //! \param val Input value, typically 1.0 for activation
   virtual void dmsUp(double val);
 
   //! \brief Controls sensor azimuth position
   //! \param val Input value in range [-1.0, 1.0]
   virtual void sensorAzimuth(double val);
 
   //! \brief Controls sensor elevation
   //! \param val Input value in range [-1.0, 1.0]
   virtual void sensorElevation(double val);
 
   //! \brief Resets sensor to default position
   //! \param val Input value, typically 1.0 for activation
   virtual void sensorReset(double val);
 
   //! \brief Commands sensor to track a location
   //! \param val Input value, typically 1.0 for activation
   virtual void sensorTrackLocation(double val);
 
   //! \brief Commands sensor to track an object
   //! \param val Input value, typically 1.0 for activation
   virtual void sensorTrackObject(double val);
 
   //! \brief Controls sensor zoom level
   //! \param val Input value in range [0.0, 1.0]
   virtual void sensorZoom(double val);
 
   //! \brief Cycles through available sensor modes
   //! \param val Input value, typically 1.0 for activation
   virtual void sensorCycle(double val);
 
   //! \brief Initiates a Synthetic Aperture Radar (SAR) request
   //! \param val Input value, typically 1.0 for activation
   virtual void sarRequest(double val);
 
   //! \brief Handles player controls state messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   //!
   //! Handles player controls state messages to cancel SAR requests if disabled.
   virtual DtVreMessageResult handlePlayerControlsState(DtVreMessage* msg);
 
protected:
   //! \brief Reference to the pilot simulation logic component
   DtPilotSimLogic& mySimLogic;
 
   //! \brief Path to the input configuration file
   std::string myConfigFile;
 
   //! \brief Flag indicating if a SAR request is active
   bool mySarRequestActive;
 
   //! \brief Pointer to the intersectors container
   makVrv::DtIntersectorsContainer* myIntersectors;
};
} // namespace makVre