lookAroundInputLogic.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file lookAroundInputLogic.h
//! \brief Input component for controlling view orientation and equipment in vehicle roles
//! \ingroup vreCommonComponents
 
#pragma once
 
#include "vreCommonComponents/export.h"
#include "vrePlayerStation/inputLogic.h"
#include "vreUtil/attribute.h"
 
#include <vreMessageManager/vreMessage.h>
 
namespace makVrv
{
class DtDe;
}
 
namespace makVre
{
class DtLookAroundObserverUpdater;
 
//! \brief Input component that enables looking around from a vehicle hatch
//!
//! DtLookAroundInputLogic provides the capability to look around as a human
//! observer from a point of view on a vehicle (i.e., an open hatch) with options
//! for binoculars and night vision. It handles inputs for view orientation,
//! equipment toggling, and mouse/joystick controls.
//!
//! Input handler details (for configuring in an SMS input configuration file):
//! - Input group: "look-around"
//! - Handler functions: "yaw", "pitch", "joystickYaw", "joystickPitch",
//!   "toggle-binoculars", "toggle-nvg", "reset-view", "enable-free-look"
class VRECOMMONCOMPONENTS_DLL DtLookAroundInputLogic : public DtInputLogic
{
public:
   //! \brief Constructor for DtLookAroundInputLogic
   //! \param de Reference to the distributed environment
   //! \param updater Reference to the associated observer updater
   //!
   //! Initializes input state with default values and establishes connection
   //! with the corresponding observer updater
   DtLookAroundInputLogic(makVrv::DtDe& de, DtLookAroundObserverUpdater& updater);
 
   //! \brief Virtual destructor for DtLookAroundInputLogic
   virtual ~DtLookAroundInputLogic() override;
 
   //! \brief Initializes the look-around input component
   //!
   //! Sets up message handlers, loads input configurations, configures input action handlers,
   //! and enables mouse control by default
   virtual void initialize() override;
 
   //! \brief Shuts down the look-around input component
   //!
   //! Removes message handlers, cleans up input configurations, and disables mouse control
   virtual void shutdown() override;
 
   //! \brief Called every frame to update view orientation based on input
   //! \param dt Delta time since the last frame in seconds
   //!
   //! Updates state attributes "observerYaw" and "observerPitch" based on mouse and joystick inputs,
   //! applying appropriate scaling based on delta time and view magnification
   virtual void tick(double dt);
 
   //! \brief Handles mouse-based yaw (horizontal rotation) input
   //! \param val Input value for yaw rate (-1.0 to 1.0)
   //!
   //! Caches the yaw input value to be applied during tick(), but only
   //! if the player is not a spectator and look-around mode is active
   virtual void yaw(double val);
 
   //! \brief Handles mouse-based pitch (vertical rotation) input
   //! \param val Input value for pitch rate (-1.0 to 1.0)
   //!
   //! Caches the pitch input value to be applied during tick(), but only
   //! if the player is not a spectator and look-around mode is active
   virtual void pitch(double val);
 
   //! \brief Handles joystick-based yaw (horizontal rotation) input
   //! \param val Input value for yaw rate (-1.0 to 1.0)
   //!
   //! Caches the joystick yaw input value to be applied during tick()
   virtual void joystickYaw(double val);
 
   //! \brief Handles joystick-based pitch (vertical rotation) input
   //! \param val Input value for pitch rate (-1.0 to 1.0)
   //!
   //! Caches the joystick pitch input value to be applied during tick()
   virtual void joystickPitch(double val);
 
   //! \brief Toggles binoculars on or off
   //! \param val Input value (1.0 to toggle binoculars)
   //!
   //! If incoming value is 1.0, toggles binoculars on/off:
   //! - If toggled on, sets zoom level to "maxViewMagnification" state attribute
   //! - If toggled off, sets zoom level to 1.0
   //! - Disables NVG if it is enabled when binoculars are toggled on
   //! - New zoom level is sent in a BinocularsZoomToMessage
   virtual void toggleBinoculars(double val);
 
   //! \brief Enables or disables binocular-specific input controls
   //! \param enabled True to enable binocular controls, false to disable
   //!
   //! Loads or unloads binocular-specific input configuration based on the enabled state
   virtual void setBinocularsControls(bool enabled);
 
   //! \brief Decreases binocular zoom level
   //! \param value Amount to decrease zoom by
   //!
   //! Sends a BinocularsZoomByMessage with a negative zoom value
   virtual void zoomOut(double value);
 
   //! \brief Increases binocular zoom level
   //! \param value Amount to increase zoom by
   //!
   //! Sends a BinocularsZoomByMessage with a positive zoom value
   virtual void zoomIn(double value);
 
   //! \brief Handles continuous zoom level input
   //! \param value Input value (-1.0 to 1.0) for zoom direction and speed
   //!
   //! Calls zoomIn for positive values or zoomOut for negative values
   virtual void zoom(double value);
 
   //! \brief Toggles night vision goggles (NVG) on or off
   //! \param val Input value (1.0 to toggle NVG)
   //!
   //! If incoming value is 1.0, toggles NVG on/off:
   //! - If toggled on, disables binoculars if they are active and sets "NVG" attribute to true
   //! - If toggled off, sets "NVG" attribute to false
   //! - Has no effect if NVG is not enabled in the component configuration
   virtual void toggleNVG(double val);
 
   //! \brief Toggles mouse control on or off
   //! \param val Input value (1.0 to toggle mouse control)
   //!
   //! Inverts the current mouse control state if the input value is 1.0
   virtual void toggleMouseControl(float val);
 
   //! \brief Enables mouse control
   //! \param val Input value (1.0 to enable mouse control)
   //!
   //! Enables mouse control if it's not already enabled and the input value is 1.0
   virtual void enableMouseControl(float val);
 
   //! \brief Handles focus state change messages
   //! \param message The focus state message
   //! \return Message handling result indicating if the message was handled
   //!
   //! Updates mouse control based on application focus state
   virtual makVre::DtVreMessageResult handleFocusMessage(makVre::DtVreMessage* message);
 
   //! \brief Sets the mouse control enabled state
   //! \param enabled True to enable mouse control, false to disable
   //!
   //! Sends a ToggleMouseControlMessage with the new state
   virtual void setMouseControlEnabled(bool enabled);
 
   //! \brief Checks if mouse control is currently enabled
   //! \return True if mouse control is enabled, false otherwise
   virtual bool isMouseControlEnabled();
 
   //! \brief Checks if mouse control support is allowed
   //! \return True if mouse control support is allowed, false otherwise
   //!
   //! This differs from isMouseControlEnabled() in that it determines whether
   //! mouse control is supported at all, not just whether it's currently active
   virtual bool isMouseControlSupportAllowed() const;
 
   //! \brief Sets whether mouse control support is allowed
   //! \param enable True to allow mouse control support, false to disallow
   //!
   //! Controls whether mouse control functionality is available at all
   virtual void setMouseControlSupportAllowed(bool enable);
 
   //! \brief Returns the view to its initial orientation
   //! \param value Input value (1.0 to reset view)
   //!
   //! If the input value is 1.0, resets the observer view to its initial orientation
   virtual void returnToInitialView(float value);
 
   //! \brief Enables or disables free-look mode
   //! \param val Input value (1.0 to enable, 0.0 to disable)
   //!
   //! Controls whether the player can freely look around, and resets
   //! input values when free-look is disabled
   virtual void freeLook(double val);
 
protected:
   //! \brief Handles menu action messages
   //! \param msg The menu action message
   //! \return Message handling result indicating if the message was handled
   //!
   //! If the incoming message action is "toggleBinoculars", calls toggleBinoculars(1)
   virtual DtVreMessageResult handleMenuMessage(makVre::DtVreMessage* msg);
 
   //! \brief Callback for changes to the usingBinoculars attribute
   //! \param usingBinoculars New value of the usingBinoculars attribute
   //!
   //! Updates the currentEquipment attribute and binoculars controls
   //! based on the new binoculars state
   void onBinocularsChanged(bool usingBinoculars);
 
protected:
   //! \brief Name of the entity this component is controlling
   std::string myEntityName;
 
   //! \brief Reference to the distributed environment
   makVrv::DtDe& myDe;
 
   //! \brief Class name for logging and identification
   std::string myClassName;
 
   //! \brief Path to the input configuration file
   std::string myInputConfigFile;
 
   //! \brief Flag indicating if mouse control is currently enabled
   bool myMouseControlEnabled;
 
   //! \brief Flag indicating if mouse control is supported at all
   bool myMouseControlSupportAllowed;
 
   //! \brief Reference to the associated look-around observer updater
   //!
   //! Used to communicate with the observer component that this input logic controls
   DtLookAroundObserverUpdater& myUpdater;
 
   //! \brief Cached mouse yaw input value
   float myMouseYawInput;
 
   //! \brief Cached mouse pitch input value
   float myMousePitchInput;
 
   //! \brief Cached joystick yaw input value
   float myJoystickYawInput;
 
   //! \brief Cached joystick pitch input value
   float myJoystickPitchInput;
 
   //! \brief Flag indicating if joystick input is currently active
   bool myJoystickMoving;
 
   //! \brief Member-scope instance of Attribute callback manager
   //!
   //! Used to manage Attribute change callback connections and ensure that all
   //! callbacks are unregistered when this class instance is destroyed.
   DtAttributeCallbackManager myAttributeCallbacks;
};
 
} // namespace makVre