humanJoystickCombatController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file humanJoystickCombatController.h
//! \ingroup vreVrfmodel
//! \brief Joystick controller for human combat capabilities
//!
//! This file defines the DtHumanJoystickCombatController class which enables joystick
//! control of combat capabilities for human entities, including weapon aiming, firing, and
//! other combat-related actions.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include <vrfobjcore/controllerComponent.h>
#include <vrfmodel/joystickControllerInterface.h>
 
class DtString;
class DtSimulationServices;
class DtJoyDeviceControllerDescriptor;
class DtJoyDevice;
class DtHumanStateRepository;
class DtBooleanOutputPort;
class DtIntegerOutputPort;
class DtAnalogOutputPort;
class DtVectorOutputPort;
class DtConstrainedAnalogOutputPort;
 
namespace makVre
{
 
//! \brief Type identifier for the human joystick combat controller component
const char DtHumanJoystickCombatControllerType[] = "human-joystick-combat-controller";
 
//! \brief Controller for joystick-based combat control of human entities
//!
//! DtHumanJoystickCombatController enables joystick control of a human entity's
//! combat capabilities. It manages weapon aiming, firing, and other combat-related
//! actions through joystick inputs. This controller works alongside movement controllers
//! to provide comprehensive control of human entities.
//!
//! Uses Descriptor Type: DtHumanJoystickCombatControllerDescriptor
class VREVRFMODEL_DLL DtHumanJoystickCombatController : public DtControllerComponent,
                                                        public DtJoystickControllerInterface
{
public:
   //! \brief Constructor
   //! \param name The name of this component
   //! \param owner The local object that owns this component
   //! \param simManager The simulation services manager
   //! \param desc Component descriptor with configuration parameters
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //!
   //! Creates a new human joystick combat controller component with the specified parameters.
   DtHumanJoystickCombatController(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the human joystick combat controller component.
   virtual ~DtHumanJoystickCombatController() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtHumanJoystickCombatControllerType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() const override;
 
   //! \brief Creates port groups for this component
   //! \return True if port groups were created successfully, false otherwise
   //!
   //! Creates and initializes the output port groups used by this controller,
   //! including groups for weapon aiming and ballistic gun control.
   virtual bool createPortGroups() override;
 
   //! \brief Creates input and output ports for this component
   //! \return True if ports were created successfully, false otherwise
   //!
   //! Creates and initializes all input and output ports used by this controller
   //! for combat-related functions, including ports for aiming, triggering, and
   //! weapon state information.
   virtual bool createPorts() override;
 
   //! \brief Factory method to create a new instance of this component
   //! \param name The name for the new component
   //! \param owner The local object that will own this component
   //! \param simManager The simulation services manager
   //! \param desc Optional component descriptor
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //! \return Pointer to the newly created component
   //!
   //! Static factory method used by the component creation system to instantiate
   //! new instances of this component type.
   static DtSimComponent* creator(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtHumanJoystickCombatController();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtHumanJoystickCombatController(const DtHumanJoystickCombatController& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   DtHumanJoystickCombatController& operator=(const DtHumanJoystickCombatController& orig);
 
protected:
   //! \brief Processes joystick input and updates output ports
   //! \param functionGroup The function group identifier for the input
   //! \param function The specific function identifier within the group
   //! \param value The input value from the joystick
   //! \param repeat Flag indicating if this is a repeated input
   //!
   //! Implements the DtJoystickControllerInterface method to process joystick
   //! input and update the controller's output ports for combat functions.
   virtual void calcAndSetPortValues(
      const DtString& functionGroup, const DtString& function, double value, bool repeat) override;
 
   //! \brief Handles joystick connection event
   //!
   //! Called when a joystick is connected to the system.
   //! Activates joystick control mode for combat functions.
   virtual void joystickConnected() override;
 
   //! \brief Handles joystick disconnection event
   //!
   //! Called when a joystick is disconnected from the system.
   //! Deactivates joystick control mode for combat functions.
   virtual void joystickDisconnected() override;
 
   //! \brief Updates the controller state each simulation frame
   //!
   //! Processes combat-related controls and updates the human entity's
   //! weapon aiming and firing state based on current joystick inputs.
   virtual void tick() override;
 
 
protected:
   //! \name Ports and Port Groups
   //! @{
 
 
   //! \brief Output port group for aiming weapon systems
   //!
   //! Contains all output ports related to weapon aiming control.
   DtOutputPortGroup* myAimWeaponOutputPortGroup;
 
   //! \brief Output port for enabling aiming at specific angles
   //!
   //! When true, allows aiming at specific elevation and azimuth angles.
   DtBooleanOutputPort* myAimAtAnglePort;
 
   //! \brief Output port for enabling azimuth aiming
   //!
   //! When true, allows aiming in azimuth (side-to-side) direction.
   DtBooleanOutputPort* myAllowAzimuthAimingPort;
 
   //! \brief Output port for azimuth aim angle
   //!
   //! Controls the azimuth angle for weapon aiming in radians.
   DtAnalogOutputPort* myAimAzimuthOutputPort;
 
   //! \brief Output port for elevation aim angle
   //!
   //! Controls the elevation angle for weapon aiming in radians.
   DtAnalogOutputPort* myAimElevationOutputPort;
 
   //! \brief Output port group for ballistic gun control
   //!
   //! Contains all output ports related to the control of ballistic guns.
   DtOutputPortGroup* myBalGunControlPortGroup;
 
   //! \brief Output port for weapon trigger state
   //!
   //! When true, indicates that the weapon trigger is pulled/activated.
   DtBooleanOutputPort* myTriggerPort;
 
   //! \brief Output port for ammunition quantity
   //!
   //! Indicates the quantity of ammunition to use for firing.
   DtIntegerOutputPort* myQuantityOutputPort;
 
   //! \brief Output port for loaded state
   //!
   //! When true, indicates that the weapon is loaded and ready to fire.
   DtBooleanOutputPort* myLoadedPort;
 
   //! \brief Output port for line-of-sight state
   //!
   //! Indicates whether a valid line-of-sight target exists.
   DtIntegerOutputPort* myLosPort;
 
   //! \brief Output port for primary joystick active state
   //!
   //! When true, indicates that primary joystick control is active.
   DtBooleanOutputPort* myActiveJoystickPort;
 
   //! \brief Output port for secondary joystick active state
   //!
   //! When true, indicates that secondary joystick control is active.
   DtBooleanOutputPort* mySecondActiveJoystickPort;
 
   //! \brief Pointer to the human state repository
   //!
   //! Access to the human entity's state information.
   DtHumanStateRepository* myHumanStateRepository;
 
   //! \brief Output port for elevation control
   //!
   //! Controls the elevation of the weapon system, with constraints on minimum and maximum values.
   DtConstrainedAnalogOutputPort* myElevationPort;
 
   //! \brief Flag indicating if the entity is currently aiming
   //!
   //! When true, the entity is actively aiming a weapon.
   bool myAiming;
 
   //! \brief Flag indicating if the trigger is currently activated
   //!
   //! When true, the weapon trigger is being pressed/activated.
   bool myTrigger;
 
   //! \brief Rate of change for pitch (elevation) control
   //!
   //! Controls how quickly the weapon elevation changes in response to inputs.
   double myPitchingRate;
 
   //! \brief Current pitch (elevation) angle
   //!
   //! Stores the current pitch/elevation angle of the weapon in radians.
   double myPitch;
 
   //! \brief Current mouse-controlled pitch contribution
   //!
   //! Stores the component of pitch that is controlled by mouse input.
   double myMousePitch;
 
   //! \brief Rate of change for yaw (azimuth) control
   //!
   //! Controls how quickly the weapon azimuth changes in response to inputs.
   double myYawingRate;
 
   //! \brief Current yaw (azimuth) angle
   //!
   //! Stores the current yaw/azimuth angle of the weapon in radians.
   double myYaw;
 
   //! \brief Current mouse-controlled yaw contribution
   //!
   //! Stores the component of yaw that is controlled by mouse input.
   double myMouseYaw;
 
   //! \brief Current state of the weapon
   //!
   //! Stores the current operational state of the weapon system.
   int myCurrentWeaponState;
 
   //! \brief Current weapon aim elevation
   //!
   //! Stores the current elevation angle being used for aiming the weapon.
   double myCurrentAimElevation;
 
   //! \brief Current weapon aim azimuth
   //!
   //! Stores the current azimuth angle being used for aiming the weapon.
   double myCurrentAimAzimuth;
};
 
} // namespace makVre