slewToCueControl.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file slewToCueControl.h
//! \brief Component for weapon system slew-to-cue functionality based on observer orientation
//! \ingroup vreCommonComponents
 
#pragma once
 
#include "vreCommonComponents/export.h"
 
#include "vrePlayerStation/playerComponent.h"
#include "vrePlayerStation/inputLogic.h"
 
namespace makVre
{
class DtPlayerStation;
 
namespace SlewToCueControlConfig
{
//! \ingroup RoleConfigParams
//! \defgroup SlewToCueControlRoleParams Slew To Cue Control Role Parameters
//! \roleInherits{PlayerComponentRoleParams}
//! Configuration Options for slew to cue control role.
//! @{
 
//! \vreRoleParam{inputConfigFile,string,"",slewToCueControl,Input configuration file path for slew-to-cue control bindings.}
constexpr const char* inputConfigFile = "inputConfigFile";
 
//! \vreRoleParam{inputConfigGroup,string,"commander",slewToCueControl,Input configuration group name for slew-to-cue controls.}
constexpr const char* inputConfigGroup = "inputConfigGroup";
 
//! \vreRoleParam{slewToCueBinding,string,"slew-to-cue",slewToCueControl,Input binding name for activating slew-to-cue functionality.}
constexpr const char* slewToCueBinding = "slewToCueBinding";
 
//! \vreRoleParam{updateDeltaAngle,double,1.0,slewToCueControl,Minimum angle change in degrees required to trigger a slew-to-cue update.}
constexpr const char* updateDeltaAngle = "updateDeltaAngle";
 
//! \vreRoleParam{updateRate,double,0.2,slewToCueControl,Maximum rate in seconds for sending slew-to-cue updates to the weapon system.}
constexpr const char* updateRate = "updateRate";
 
//! \vreRoleParam{weaponSystemToSlew,string,"weapon",slewToCueControl,Name of the weapon system component to control for slew-to-cue operations.}
constexpr const char* weaponSystemToSlew = "weaponSystemToSlew";
 
//! @}
} // namespace SlewToCueControlConfig
 
//! \brief Type identifier for DtSlewToCueControl component
constexpr const char* DtSlewToCueControlType = "DtSlewToCueControl";
 
//! \brief Component that enables slew-to-cue functionality for weapon systems
//!
//! DtSlewToCueControl provides the ability to send slew-to-cue commands to a specified
//! weapon system, directing it to orient toward the player's current view direction.
//! It requires a DtWeaponPoseUpdater component to obtain the current weapon position
//! and orientation data. The component supports rate-limited updates and angle thresholds
//! to optimize network traffic when sending cue commands.
class VRECOMMONCOMPONENTS_DLL DtSlewToCueControl : public DtPlayerComponent
{
public:
   //! \brief Constructor for DtSlewToCueControl
   //!
   //! Initializes the component with default settings for slew control
   DtSlewToCueControl();
 
   //! \brief Virtual destructor for DtSlewToCueControl
   virtual ~DtSlewToCueControl() override;
 
   //! \brief Initializes the slew-to-cue control component
   //! \param player Pointer to the player station this component belongs to
   //! \param config Configuration table containing slew control settings
   //! \return True if initialization succeeded, false otherwise
   //!
   //! Reads configuration settings for the weapon system to slew, update rate,
   //! update delta angle, and sets up input bindings for activation
   virtual bool initialize(DtPlayerStation* player, DtInitTable& config) override;
   //! \brief Performs post-initialization after all components are initialized
   //! \return True if post-initialization succeeded, false otherwise
   //!
   //! Verifies the presence of weaponLocation and weaponOrientation attributes
   //! and sets up the attribute change callback for orientation updates
   virtual bool postInitialize() override;
 
   //! \brief Called every frame to update the slew control state
   //! \param dt Delta time since the last frame in seconds
   //!
   //! When slewing is active, manages update timing and sends slew-to-cue
   //! messages based on the configured update rate and angle thresholds
   virtual void tick(double dt) override;
   //! \brief Shuts down the slew-to-cue control component
   //!
   //! Removes attribute change callbacks, deactivates slewing if active,
   //! and performs base class shutdown operations
   virtual void shutdown() override;
 
   //! \brief Returns the type identifier for this component
   //! \return The type string for DtSlewToCueControl
   virtual const char* type() const override;
 
   //! \brief Input handler for activating/deactivating slew-to-cue
   //! \param val Input value (1.0 for activation, 0.0 for deactivation)
   //!
   //! Activates slew-to-cue when input is pressed and deactivates it when released,
   //! sending appropriate messages to the weapon system
   virtual void activateSlewToCue(double val);
 
protected:
   //! \brief Callback for weapon orientation attribute changes
   //! \param ori New orientation value
   //!
   //! Determines if the orientation change exceeds the configured delta angle
   //! threshold and sets the update needed flag accordingly
   virtual void weaponOrientationAttributeUpdated(DtTaitBryan ori);
 
   //! \brief Input logic for handling slew control input bindings
   DtInputLogic myInputLogic;
 
   //! \brief Name of the weapon system to send slew commands to
   std::string myWeaponSystemToSlew;
 
   //! \brief Flag indicating if slewing is currently active
   bool mySlewingActive;
 
   //! \brief Flag indicating if an update needs to be sent
   bool myUpdateNeeded;
 
   //! \brief Minimum time between slew updates in seconds
   double myUpdateRate;
 
   //! \brief Timer tracking time until next possible update
   double myUpdateTimer;
 
   //! \brief Minimum angle change in degrees to trigger an update
   double myUpdateDeltaAngle;
 
   //! \brief Last sent forward vector for angle change comparison
   DtVector32 myLastSentVector;
};
 
} // namespace makVre