commanderControlLogic.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file commanderControlLogic.h
//! \brief Defines the DtCommanderControlLogic component for controlling commander sensor systems.
//!
//! This component provides functionality for orienting and controlling sensor systems used by
//! vehicle commanders, including azimuth, elevation, zoom, and sensor mode switching capabilities.
//!
//! \ingroup vreCommonComponents
 
#pragma once
 
#include "vreCommonComponents/export.h"
 
#include "vrePlayerStation/entityControlLogic.h"
 
namespace makVre
{
namespace CommanderControlLogicConfig
{
//! \ingroup RoleConfigParams
//! \defgroup CommanderControlLogicRoleParams Commander Control Logic Role Parameters
//! \roleInherits{EntityControlLogicRoleParams}
//! Configuration Options for commander control logic role.
//! @{
 
//! \vreRoleParam{enableZoom,bool,false,commanderControlLogic,Determines whether zoom functionality is available in out the hatch mode.}
constexpr const char* enableZoom = "enableZoom";
 
//! \vreRoleParam{maxZoom,double,32.0,commanderControlLogic,Maximum allowable zoom magnification level for the sensor system.}
constexpr const char* maxZoom = "maxZoom";
 
//! \vreRoleParam{minZoom,double,1.0,commanderControlLogic,Minimum allowable zoom magnification level for the sensor system.}
constexpr const char* minZoom = "minZoom";
 
//! \vreRoleParam{outTheHatchMode,bool,false,commanderControlLogic,Enables out the hatch mode where sensor control directly affects observer view rather than sending joystick messages.}
constexpr const char* outTheHatchMode = "outTheHatchMode";
 
//! @}
} // namespace CommanderControlLogicConfig
 
//! \brief Type identifier for DtCommanderControlLogic component
constexpr const char* DtCommanderControlLogicType = "DtCommanderControlLogic";
 
//! \brief Component for controlling commander sensor systems in vehicles
//!
//! The DtCommanderControlLogic provides control functionality for vehicle commander
//! sensor systems, supporting orientation in azimuth and elevation, zoom control,
//! and the ability to switch between different sensor modes (e.g., IR, NVG, visual).
//!
//! Input handler details (for configuring in an SMS input configuration file):
//!
//! This class has the following input handler functions that may be configured
//! to map to input devices in role input configuration files:
//! - "sensor-azimuth": Controls horizontal rotation of the sensor
//! - "sensor-elevation": Controls vertical tilt of the sensor
//! - "sensor-zoom-in": Increases sensor magnification
//! - "sensor-zoom-out": Decreases sensor magnification
//! - "sensor-zoom": Combined zoom in/out based on positive/negative values
//! - "next-sensor": Cycles through available sensor modes
//!
//! The group name is provided in the role configuration file and is used to
//! distinguish input handlers when multiple handlers are present on the entity.
class VRECOMMONCOMPONENTS_DLL DtCommanderControlLogic : public makVre::DtEntityControlLogic
{
public:
   //! \brief Constructor for DtCommanderControlLogic
   //!
   //! Initializes the component with the name "DtCommanderControlLogic" and default values.
   //! Also checks out the required VR Engage Ground license.
   DtCommanderControlLogic();
 
   //! \brief Virtual destructor for DtCommanderControlLogic
   virtual ~DtCommanderControlLogic() override;
 
   //! \brief Initializes the component with configuration from Lua
   //!
   //! Sets up input handlers, zoom limits, and initializes state attributes needed
   //! for sensor control. Configures the component based on provided configuration.
   //!
   //! \param player Pointer to the player station this component belongs to
   //! \param config Configuration table containing initialization parameters
   //! \return True if initialization succeeds, false otherwise
   virtual bool initialize(makVre::DtPlayerStation* player, makVre::DtInitTable& config) override;
 
   //! \brief Performs post-initialization setup
   //!
   //! Sets up input handler callbacks after all components have been initialized.
   //!
   //! \return True if post-initialization succeeds, false otherwise
   virtual bool postInitialize() override;
 
   //! \brief Updates the component state
   //!
   //! Called each frame to handle sensor control logic, particularly
   //! handling special cases like "out the hatch" mode.
   //!
   //! \param dt Delta time in seconds since the last tick
   virtual void tick(double dt) override;
 
   //! \brief Shuts down the component
   //!
   //! Cleans up resources and disconnects input handlers.
   virtual void shutdown() override;
 
   //! \brief Returns the component type identifier
   //! \return The component type string
   virtual const char* type() const override;
 
   //! \brief Input handler for sensor azimuth (horizontal) control
   //!
   //! Controls the horizontal rotation of the sensor. In normal mode, sends joystick
   //! messages scaled by the current zoom level. In "out the hatch" mode, stores the
   //! input value for processing during tick().
   //!
   //! \param val The azimuth input value, typically from -1.0 to 1.0
   virtual void azimuth(double val);
 
   //! \brief Input handler for sensor elevation (vertical) control
   //!
   //! Controls the vertical tilt of the sensor. In normal mode, sends joystick
   //! messages scaled by the current zoom level. In "out the hatch" mode, stores the
   //! input value for processing during tick().
   //!
   //! \param val The elevation input value, typically from -1.0 to 1.0
   virtual void elevation(double val);
 
   //! \brief Input handler for zoom in functionality
   //!
   //! Increases the sensor's magnification level by a factor of 2, up to the
   //! configured maximum zoom level.
   //!
   //! \param val The zoom in input value, positive values trigger zoom
   virtual void zoomIn(double val);
 
   //! \brief Input handler for zoom out functionality
   //!
   //! Decreases the sensor's magnification level by a factor of 0.5, down to the
   //! configured minimum zoom level.
   //!
   //! \param val The zoom out input value, positive values trigger zoom
   virtual void zoomOut(double val);
 
   //! \brief Combined input handler for zoom functionality
   //!
   //! Routes to zoomIn or zoomOut based on whether the input value is positive or negative.
   //!
   //! \param val The zoom input value, positive for zoom in, negative for zoom out
   virtual void zoom(float val);
 
   //! \brief Input handler for cycling through sensor modes
   //!
   //! Cycles to the next available sensor mode (e.g., visual, NVG, thermal) when triggered.
   //!
   //! \param val The input value, a value of 1.0 triggers the sensor change
   virtual void nextSensor(double val);
 
   //! \brief Handles menu action messages
   //!
   //! Processes menu actions, particularly the "cycleSensor" action which
   //! triggers the nextSensor functionality.
   //!
   //! \param msg The message to process
   //! \return HANDLED if the message was processed, IGNORED otherwise
   virtual makVre::DtVreMessageResult handleMenuMessage(makVre::DtVreMessage* msg);
 
protected:
   //! \brief Input handler logic for processing input device events
   DtInputLogic myInputLogic;
 
   //! \brief Main control group name from configuration
   //!
   //! Used to identify the function group when sending joystick messages.
   std::string myMainControlGroup;
 
   //! \brief Flag indicating whether "out the hatch" mode is active
   //!
   //! When true, sensor control directly affects the observer view rather
   //! than sending joystick messages to control a vehicle sensor.
   bool myOutTheHatchMode;
 
   //! \brief Current azimuth input value for "out the hatch" mode
   float myAzimuthInput;
 
   //! \brief Current elevation input value for "out the hatch" mode
   float myElevationInput;
 
   //! \brief Maximum allowed zoom level
   float myMaxZoom;
 
   //! \brief Minimum allowed zoom level
   float myMinZoom;
   bool myEnableZoom;
};
} // namespace makVre