humanInputLogic.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file humanInputLogic.h
//! \brief Defines DtHumanInputLogic for handling human-specific inputs
//! \ingroup vreHumanFrontend
 
#pragma once
 
#include "vreHumanFrontEnd/export.h"
#include <vrePlayerStation/inputLogic.h>
 
namespace makVre
{
//! \brief Forward declaration of the human control logic class
class DtHumanControlLogic;
 
//! \brief Input logic component for the human role
//!
//! DtHumanInputLogic manages user input processing for the human role,
//! handling keyboard, mouse, and controller inputs for character movement,
//! weapon operations, view modes, and special equipment. It translates raw input
//! values into appropriate control actions for the human entity.
class HUMAN_DLL DtHumanInputLogic : public DtInputLogic
{
public:
   //! \brief Constructor
   //! \param simLogic Reference to the human control logic component
   //! \param configFile Path to the input configuration file
   DtHumanInputLogic(DtHumanControlLogic& simLogic, const std::string& configFile);
 
   //! \brief Virtual destructor
   virtual ~DtHumanInputLogic() override;
 
   //! \brief Initializes the input logic component
   //!
   //! Sets up input bindings and default configuration
   virtual void initialize() override;
 
   //! \brief Loads a specific input configuration group
   //! \param group Name of the configuration group to load
   virtual void loadConfigGroup(const std::string& group);
 
   //! \brief Unloads a specific input configuration group
   //! \param group Name of the configuration group to unload
   virtual void unloadConfigGroup(const std::string& group);
 
   //! \brief Handles forward/backward movement input
   //! \param value Input value in the range [-1.0, 1.0], where positive is forward
   virtual void move(float value);
 
   //! \brief Handles left/right movement input
   //! \param value Input value in the range [-1.0, 1.0], where positive is right
   virtual void strafe(float value);
 
   //! \brief Handles yaw (left/right turning) input
   //! \param value Input value in the range [-1.0, 1.0], where positive is right
   virtual void yaw(float value);
 
   //! \brief Handles pitch (up/down looking) input
   //! \param value Input value in the range [-1.0, 1.0], where positive is down
   virtual void pitch(float value);
 
   //! \brief Handles mouse-specific yaw input
   //! \param value Input value derived from mouse movement
   virtual void mouseYaw(float value);
 
   //! \brief Handles mouse-specific pitch input
   //! \param value Input value derived from mouse movement
   virtual void mousePitch(float value);
 
   //! \brief Activates sprint movement
   //! \param value Input value, typically 1.0 for activation
   virtual void sprint(float value);
 
   //! \brief Activates walk movement
   //! \param value Input value, typically 1.0 for activation
   virtual void walk(float value);
 
   //! \brief Handles forward movement input
   //! \param value Input value, typically 1.0 for full forward
   virtual void moveForward(float value);
 
   //! \brief Handles backward movement input
   //! \param value Input value, typically 1.0 for full backward
   virtual void moveBackward(float value);
 
   //! \brief Handles leftward movement input
   //! \param value Input value, typically 1.0 for full left
   virtual void strafeLeft(float value);
 
   //! \brief Handles rightward movement input
   //! \param value Input value, typically 1.0 for full right
   virtual void strafeRight(float value);
 
   //! \brief Handles leftward turning input
   //! \param value Input value, typically 1.0 for activation
   virtual void yawLeft(float value);
 
   //! \brief Handles rightward turning input
   //! \param value Input value, typically 1.0 for activation
   virtual void yawRight(float value);
 
   //! \brief Handles upward looking input
   //! \param value Input value, typically 1.0 for activation
   virtual void pitchUp(float value);
 
   //! \brief Handles downward looking input
   //! \param value Input value, typically 1.0 for activation
   virtual void pitchDown(float value);
   //! \brief Selects posture based on current state
   //! \param value Input value, typically 1.0 for activation
   virtual void postureSelect(float value);
 
   //! \brief Transitions to a more upright posture
   //! \param value Input value, typically 1.0 for activation
   virtual void postureUp(float value);
 
   //! \brief Transitions to a more prone posture
   //! \param value Input value, typically 1.0 for activation
   virtual void postureDown(float value);
 
   //! \brief Transitions to standing posture
   //! \param value Input value, typically 1.0 for activation
   virtual void postureStand(float value);
 
   //! \brief Transitions to prone posture
   //! \param value Input value, typically 1.0 for activation
   virtual void postureProne(float value);
 
   //! \brief Fires the current weapon
   //! \param value Input value, typically 1.0 for activation
   virtual void fire(float value);
 
   //! \brief Initiates weapon reload
   //! \param value Input value, typically 1.0 for activation
   virtual void reload(float value);
 
   //! \brief Activates aiming mode
   //! \param value Input value, typically 1.0 for activation
   virtual void aim(float value);
 
   //! \brief Cycles through available weapons
   //! \param value Input value, typically 1.0 for activation
   virtual void weaponCycle(float value);
 
   //! \brief Switches to the next weapon
   //! \param value Input value, typically 1.0 for activation
   virtual void nextWeapon(float value);
   //! \brief Selects a specific weapon by index
   //! \param value Input value, typically 1.0 for activation
   //! \param index Index of the weapon to select (0-based)
   virtual void selectWeapon(float value, int index);
 
   //! \brief Selects weapon 1
   //! \param value Input value, typically 1.0 for activation
   virtual void selectWeapon1(float value);
 
   //! \brief Selects weapon 2
   //! \param value Input value, typically 1.0 for activation
   virtual void selectWeapon2(float value);
 
   //! \brief Selects weapon 3
   //! \param value Input value, typically 1.0 for activation
   virtual void selectWeapon3(float value);
 
   //! \brief Selects weapon 4
   //! \param value Input value, typically 1.0 for activation
   virtual void selectWeapon4(float value);
 
   //! \brief Selects weapon 5
   //! \param value Input value, typically 1.0 for activation
   virtual void selectWeapon5(float value);
 
   //! \brief Selects weapon 6
   //! \param value Input value, typically 1.0 for activation
   virtual void selectWeapon6(float value);
 
   //! \brief Selects weapon 7
   //! \param value Input value, typically 1.0 for activation
   virtual void selectWeapon7(float value);
 
   //! \brief Selects weapon 8
   //! \param value Input value, typically 1.0 for activation
   virtual void selectWeapon8(float value);
 
   //! \brief Selects weapon 9
   //! \param value Input value, typically 1.0 for activation
   virtual void selectWeapon9(float value);
 
   //! \brief Selects weapon 10
   //! \param value Input value, typically 1.0 for activation
   virtual void selectWeapon10(float value);
   //! \brief Toggles weapon stowed state
   //! \param value Input value, typically 1.0 for activation
   virtual void toggleWeaponStowed(float value);
 
   //! \brief Toggles weapon down state
   //! \param value Input value, typically 1.0 for activation
   virtual void toggleWeaponDown(float value);
 
   //! \brief Toggles HUD visibility
   //! \param value Input value, typically 1.0 for activation
   //!
   //! Action handler for "toggle-HUD" control. Calls corresponding function in mySimLogic.
   virtual void toggleHUD(float value);
 
   //! \brief Cycles through weapon states (ready, down, stowed)
   //! \param value Input value, typically 1.0 for activation
   virtual void cycleWeaponState(float value);
 
   //! \brief Toggles free look mode
   //! \param value Input value, typically 1.0 for activation
   virtual void freeLook(float value);
 
   //! \brief Switches to first-person view mode
   //! \param value Input value, typically 1.0 for activation
   virtual void firstPersonMode(float value);
 
   //! \brief Switches to third-person view mode
   //! \param value Input value, typically 1.0 for activation
   virtual void thirdPersonMode(float value);
 
   //! \brief Toggles between view modes
   //! \param value Input value, typically 1.0 for activation
   virtual void toggleViewMode(float value);
 
   //! \brief Toggles night vision goggles
   //! \param value Input value, typically 1.0 for activation
   virtual void toggleNVG(float value);
 
   //! \brief Toggles binoculars equipment
   //! \param value Input value, typically 1.0 for activation
   virtual void toggleBinoculars(float value);
 
   //! \brief Toggles flashlight on/off
   //! \param value Input value, typically 1.0 for activation
   virtual void toggleFlashlight(float value);
 
   //! \brief Toggles compass display
   //! \param value Input value, typically 1.0 for activation
   virtual void toggleCompass(float value);
 
   //! \brief Toggles between compass unit types
   //! \param value Input value, typically 1.0 for activation
   virtual void toggleCompassUnits(float value);
 
   //! \brief Deploys the parachute
   //! \param value Input value, typically 1.0 for activation
   virtual void parachuteDeploy(float value);
 
   //! \brief Enables or disables parachute controls
   //! \param enabled True to enable parachute controls, false to disable
   virtual void setParachuteControls(bool enabled);
 
   //! \brief Toggles left parachute control
   //! \param value Input value, typically 1.0 for activation
   virtual void parachuteLeftToggle(float value);
 
   //! \brief Toggles right parachute control
   //! \param value Input value, typically 1.0 for activation
   virtual void parachuteRightToggle(float value);
 
   //! \brief Cycles minimap display modes
   //! \param value Input value, typically 1.0 for activation
   virtual void minimapCycle(float value);
 
   //! \brief Zooms in the minimap
   //! \param value Input value, typically 1.0 for activation
   virtual void minimapZoomIn(float value);
 
   //! \brief Zooms out the minimap
   //! \param value Input value, typically 1.0 for activation
   virtual void minimapZoomOut(float value);
 
   //! \brief Resets minimap zoom to default
   //! \param value Input value, typically 1.0 for activation
   virtual void minimapResetZoom(float value);
 
   //! \brief Toggles AR camera menu display
   //! \param value Input value, typically 1.0 for activation
   virtual void toggleARCameraMenu(float value);
 
   //! \brief Enables or disables binoculars-specific controls
   //! \param enabled True to enable binoculars controls, false to disable
   virtual void setBinocularsControls(bool enabled);
 
   //! \brief Zooms in with current optical equipment
   //! \param value Input value, typically 1.0 for activation
   virtual void zoomIn(float value);
 
   //! \brief Zooms out with current optical equipment
   //! \param value Input value, typically 1.0 for activation
   virtual void zoomOut(float value);
 
   //! \brief Controls continuous zoom level
   //! \param value Input value in the range [-1.0, 1.0], where positive is zoom in
   virtual void zoom(float value);
 
   //! \brief Enables or disables launcher-specific controls
   //! \param enabled True to enable launcher controls, false to disable
   virtual void setLauncherControls(bool enabled);
 
   //! \brief Handles first stage trigger input for weapons
   //! \param value Input value, typically 1.0 for activation
   virtual void firstStageTrigger(float value);
 
   //! \brief Toggles the missile attack mode
   //! \param value Input value, typically 1.0 for activation
   //!
   //! Toggles between top attack mode and direct attack mode for missile launchers
   virtual void toggleMissileAttackMode(float value);
 
   //! \brief Enables or disables scope-specific controls
   //! \param enabled True to enable scope controls, false to disable
   virtual void setScopeControls(bool enabled);
 
   //! \brief Enables or disables drone-specific controls
   //! \param enabled True to enable drone controls, false to disable
   virtual void setDroneControls(bool enabled);
 
   //! \brief Toggles remote view viewport for drone
   //! \param value Input value, typically 1.0 for activation
   virtual void toggleRemoteViewViewport(float value);
 
   //! \brief Toggles focus on controlled drone
   //! \param value Input value, typically 1.0 for activation
   virtual void toggleFocusOnDrone(float value);
 
   //! \brief Toggles drone PID control menu
   //! \param value Input value, typically 1.0 for activation
   virtual void toggleDronePIDMenu(float value);
 
   //! \brief Controls drone collective (vertical movement)
   //! \param value Input value in the range [-1.0, 1.0], where positive is up
   virtual void droneCollective(float value);
 
   //! \brief Controls drone pitch (forward/backward tilt)
   //! \param value Input value in the range [-1.0, 1.0], where positive is down
   virtual void dronePitch(float value);
 
   //! \brief Controls drone roll (left/right tilt)
   //! \param value Input value in the range [-1.0, 1.0], where positive is right
   virtual void droneRoll(float value);
 
   //! \brief Controls drone pedal (yaw/rotation)
   //! \param value Input value in the range [-1.0, 1.0], where positive is right
   virtual void dronePedal(float value);
 
   //! \brief Controls drone wheel brake
   //! \param value Input value, typically 1.0 for activation
   virtual void droneWheelBrake(float value);
 
   //! \brief Controls drone camera elevation
   //! \param value Input value in the range [-1.0, 1.0], where positive is down
   virtual void droneCameraElevation(float value);
 
   //! \brief Controls drone camera zoom
   //! \param value Input value in the range [-1.0, 1.0], where positive is zoom in
   virtual void droneCameraZoom(float value);
 
   //! \brief Captures an image from the drone camera
   //! \param value Input value, typically 1.0 for activation
   virtual void droneCaptureImage(float value);
 
protected:
   //! \brief Sends a joystick command to the controlled drone
   //! \param functionGroup Function group name for the command
   //! \param function Function name for the command
   //! \param value Command value
   virtual void sendDroneJoystickCommand(const std::string& functionGroup, const std::string& function, double value);
 
   //! \brief Reference to the human control logic component
   DtHumanControlLogic& mySimLogic;
 
   //! \brief Path to the input configuration file
   std::string myConfigFile;
 
   //! \brief Flag indicating if binoculars controls are enabled
   bool myBinocularsEnabled;
 
   //! \brief Flag indicating if scope controls are enabled
   bool myScopeEnabled;
};
} // namespace makVre