gunnerRangeSimLogic.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file gunnerRangeSimLogic.h
//! \brief Component that computes range to target for gunner and weapon systems
//! \ingroup vreCommonComponents
 
#pragma once
 
#include "vreCommonComponents/export.h"
 
#include "vrePlayerStation/playerComponent.h"
 
#include "vreUtil/initializer.h"
 
namespace makVre
{
class DtVreMessage;
 
namespace GunnerRangeSimLogicConfig
{
//! \ingroup RoleConfigParams
//! \defgroup GunnerRangeSimLogicRoleParams Gunner Range Sim Logic Role Parameters
//! \roleInherits{PlayerComponentRoleParams}
//! Configuration Options for gunner range simulation logic role.
//! @{
 
//! \vreRoleParam{channelName,string,"Channel 1",gunnerRangeSimLogic,Name of the display channel used for range computation ray casting.}
constexpr const char* channelName = "channelName";
 
//! \vreRoleParam{updateInterval,double,1.0,gunnerRangeSimLogic,Time interval in seconds between range computation updates.}
constexpr const char* updateInterval = "updateInterval";
 
//! \vreRoleParam{windowName,string,"Window 1",gunnerRangeSimLogic,Name of the display window used for range computation ray casting.}
constexpr const char* windowName = "windowName";
 
//! @}
} // namespace GunnerRangeSimLogicConfig
 
class DtVreMessage;
class DtGunnerJoystickControl;
class DtGunnerEventProcessor;
 
//! \brief Type identifier for DtGunnerRangeSimLogic component
constexpr const char* DtGunnerRangeSimLogicType = "DtGunnerRangeSimLogic";
 
//! \brief Component that periodically computes the range to target for gunner systems
//!
//! DtGunnerRangeSimLogic periodically computes the range from the entity to the first
//! object or terrain polygon it intersects. It casts a ray from the observer through
//! the center point of the screen and sets the player attribute "range" with the
//! distance in meters. The computation occurs at a configurable time interval.
class VRECOMMONCOMPONENTS_DLL DtGunnerRangeSimLogic : public DtPlayerComponent
{
public:
   //! \brief Constructor for DtGunnerRangeSimLogic
   //!
   //! Initializes component with default values for update interval (1 second),
   //! window name ("Window 1"), and channel name ("Channel 1")
   DtGunnerRangeSimLogic();
 
   //! \brief Destructor for DtGunnerRangeSimLogic
   virtual ~DtGunnerRangeSimLogic() override;
 
   //! \brief Initializes the gunner range simulation component
   //! \param player Pointer to the player station this component belongs to
   //! \param config Configuration table containing range simulation settings
   //! \return True if initialization succeeded, false otherwise
   //!
   //! Configures the component with the following parameters from the configuration table:
   //! - updateInterval: Time in seconds between range updates (default: 1 second)
   //! - windowName: Name of the window to use for ray casting (default: "Window 1")
   //! - channelName: Name of the channel to use for ray casting (default: "Channel 1")
   //!
   //! Also initializes the "range" player attribute to 0.0
   virtual bool initialize(DtPlayerStation* player, DtInitTable& config) override;
 
   //! \brief Called every frame to update the range simulation
   //! \param dt Delta time since the last frame in seconds
   //!
   //! Calls updateRange() each tick to calculate the current range to target
   virtual void tick(double dt) override;
 
   //! \brief Shuts down the gunner range simulation component
   //!
   //! Performs any necessary cleanup operations
   virtual void shutdown() override;
 
   //! \brief Returns the type identifier for this component
   //! \return The type string for DtGunnerRangeSimLogic
   virtual const char* type() const override;
 
protected:
   //! \brief Computes the range to target at specified time intervals
   //!
   //! Called each tick to determine if it's time to update the range value.
   //! When triggered, casts a ray from the observer through the center of the screen
   //! and computes the distance to the first intersection. Sets the player attribute
   //! "range" with the calculated distance in meters.
   virtual void updateRange();
 
   //! \brief Simulation time at which the next range update should be computed
   double myTimeToUpdate;
 
   //! \brief Time interval in seconds between range updates
   //!
   //! Defaults to 1.0 second if not specified in configuration
   double myUpdateInterval;
 
   //! \brief Name of the window to use for ray casting
   //!
   //! Defaults to "Window 1" if not specified in configuration
   std::string myWindowName;
 
   //! \brief Name of the channel to use for ray casting
   //!
   //! Defaults to "Channel 1" if not specified in configuration
   std::string myChannelName;
};
} // namespace makVre