topAndDirectAttackMissileControllerDescriptor.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file topAndDirectAttackMissileControllerDescriptor.h
//! \ingroup vreVrfobjparam
//! \brief Top and direct attack missile controller descriptor for VREngage
//!
//! This file defines the DtTopAndDirectAttackMissileControllerDescriptor class, which
//! configures missile flight behavior for FGM-148 Javelin-style missiles in VREngage.
//! It provides parameters for both top-attack and direct-attack flight profiles.
 
#pragma once
 
#include "vreVrfobjparam/export.h"
 
#include <vrfobjparam/componentDescriptor.h>
 
//! \brief Flight modes and phases of the missile:
//!
//! The FGM-148 Javelin-style missile has two modes of flight:
//!
//! 1. Top-Attack Mode:
//!    - Climb-out Phase: Missile flies out at a steep angle
//!    - Altitude-hold Phase: Missile flies toward the target at maximum altitude
//!    - Terminal Phase: Missile flies directly toward the target at a specified terminal angle
//!
//!    Note: If the target is close enough, the missile may not reach the altitude
//!    hold phase and may proceed directly to terminal phase.
//!
//! 2. Direct-Attack Mode:
//!    - Climb-out Phase: Missile flies out at a moderate angle
//!    - Terminal Phase: Missile flies directly toward the target at a specified terminal angle
//!
//! The default parameter values are based on estimates from FM 3-22.37
//! "Javelin--Close Combat Missile System, Medium".
 
namespace makVre
{
//! \brief Type identifier string for the top and direct attack missile controller descriptor
//!
//! Key used for this class in DtSimComponentFactory.
const char DtTopAndDirectAttackMissileControllerDescriptorType[] = "top-and-direct-attack-missile-descriptor";
 
//! \brief Top and direct attack missile controller descriptor for VREngage
//!
//! This class defines the flight behavior parameters for FGM-148 Javelin-style
//! missiles in VREngage simulations. It provides configuration for both top-attack
//! and direct-attack flight profiles, including climb angles, terminal angles,
//! maximum altitudes, and range limitations.
class VREVRFOBJPARAM_DLL DtTopAndDirectAttackMissileControllerDescriptor : public DtComponentDescriptor
{
public:
   //! \brief Constructor with component name
   //! \param componentName The name of this component
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //!
   //! Creates a new top and direct attack missile controller descriptor with the specified name.
   //! The component name is the name of the descriptor entry as it appears in a parameter database file.
   DtTopAndDirectAttackMissileControllerDescriptor(
      const DtString& componentName, DtReaderWriterRegistry* parentRegistry = NULL);
 
   //! \brief Constructor with component name as symbol string
   //! \param componentName The name of this component as a symbol string
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //!
   //! Creates a new top and direct attack missile controller descriptor with the specified name.
   DtTopAndDirectAttackMissileControllerDescriptor(
      const DtSymbolString& componentName, DtReaderWriterRegistry* parentRegistry = NULL);
 
   //! \brief Copy constructor
   //! \param orig The source descriptor to copy from
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //!
   //! Creates a new top and direct attack missile controller descriptor as a copy of the provided original.
   DtTopAndDirectAttackMissileControllerDescriptor(
      const DtTopAndDirectAttackMissileControllerDescriptor& orig, DtReaderWriterRegistry* parentRegistry = NULL);
 
   //! \brief Assignment operator
   //! \param orig The source descriptor to copy from
   //! \return Reference to this descriptor after assignment
   //!
   //! Assigns the contents of the provided descriptor to this one.
   DtTopAndDirectAttackMissileControllerDescriptor& operator=(
      const DtTopAndDirectAttackMissileControllerDescriptor& orig);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the descriptor.
   virtual ~DtTopAndDirectAttackMissileControllerDescriptor() override;
 
   //! \brief Gets the type identifier for this descriptor
   //! \return String identifying this descriptor type
   //!
   //! Returns a unique type identifier string for this descriptor type.
   //! Will return DtTopAndDirectAttackMissileControllerDescriptorType.
   virtual DtString type() const override;
 
   //! \brief Creates a clone of this descriptor
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //! \return Pointer to a new descriptor that is a clone of this one
   //!
   //! Creates a new top and direct attack missile controller descriptor as a deep copy of this one.
   virtual DtComponentDescriptor* clone(DtReaderWriterRegistry* parentRegistry = NULL) const override;
 
   //! \brief Factory function to create a new instance of this descriptor
   //! \return Pointer to a newly created descriptor
   //!
   //! Static factory function used by the descriptor creation system to instantiate
   //! new instances of this descriptor type. Creation methods are registered with a
   //! DtComponentDescriptorFactory, so they can be created on demand as they
   //! are read in from a parameter database file.
   static DtComponentDescriptor* creator();
 
   //! \brief Equality operator
   //! \param other The descriptor to compare with
   //! \return True if the descriptors are equal, false otherwise
   //!
   //! Compares this descriptor with another to determine if they are equal.
   bool operator==(const DtTopAndDirectAttackMissileControllerDescriptor& other) const;
 
   //! \name Top-Attack Mode Parameters
   //! @{
 
   //! \brief Sets the climb-out angle for top-attack mode
   //! \param angle The climb-out angle in radians
   //!
   //! Sets the angle at which the missile initially climbs during top-attack mode.
   virtual void setTopAttackClimbOutAngle(double angle);
 
   //! \brief Gets the climb-out angle for top-attack mode
   //! \return The climb-out angle in radians
   //!
   //! Returns the angle at which the missile initially climbs during top-attack mode.
   virtual double topAttackClimbOutAngle() const;
 
   //! \brief Sets the terminal angle for top-attack mode
   //! \param angle The terminal angle in radians
   //!
   //! Sets the angle at which the missile approaches the target in terminal phase
   //! during top-attack mode.
   virtual void setTopAttackTerminalAngle(double angle);
 
   //! \brief Gets the terminal angle for top-attack mode
   //! \return The terminal angle in radians
   //!
   //! Returns the angle at which the missile approaches the target in terminal phase
   //! during top-attack mode.
   virtual double topAttackTerminalAngle() const;
 
   //! \brief Sets the maximum altitude for top-attack mode
   //! \param altitude The maximum altitude in meters
   //!
   //! Sets the maximum altitude the missile reaches during altitude-hold phase
   //! in top-attack mode.
   virtual void setTopAttackMaxAltitude(double altitude);
 
   //! \brief Gets the maximum altitude for top-attack mode
   //! \return The maximum altitude in meters
   //!
   //! Returns the maximum altitude the missile reaches during altitude-hold phase
   //! in top-attack mode.
   virtual double topAttackMaxAltitude() const;
 
   //! \brief Sets the minimum range for top-attack mode
   //! \param range The minimum range in meters
   //!
   //! Sets the minimum range at which top-attack mode can be effectively used.
   virtual void setTopAttackMinRange(double range);
 
   //! \brief Gets the minimum range for top-attack mode
   //! \return The minimum range in meters
   //!
   //! Returns the minimum range at which top-attack mode can be effectively used.
   virtual double topAttackMinRange() const;
 
   //! @}
 
   //! \name Direct-Attack Mode Parameters
   //! @{
 
   //! \brief Sets the climb-out angle for direct-attack mode
   //! \param angle The climb-out angle in radians
   //!
   //! Sets the angle at which the missile initially climbs during direct-attack mode.
   virtual void setDirectAttackClimbOutAngle(double angle);
 
   //! \brief Gets the climb-out angle for direct-attack mode
   //! \return The climb-out angle in radians
   //!
   //! Returns the angle at which the missile initially climbs during direct-attack mode.
   virtual double directAttackClimbOutAngle() const;
 
   //! \brief Sets the terminal angle for direct-attack mode
   //! \param angle The terminal angle in radians
   //!
   //! Sets the angle at which the missile approaches the target in terminal phase
   //! during direct-attack mode.
   virtual void setDirectAttackTerminalAngle(double angle);
 
   //! \brief Gets the terminal angle for direct-attack mode
   //! \return The terminal angle in radians
   //!
   //! Returns the angle at which the missile approaches the target in terminal phase
   //! during direct-attack mode.
   virtual double directAttackTerminalAngle() const;
 
   //! \brief Sets the maximum altitude for direct-attack mode
   //! \param altitude The maximum altitude in meters
   //!
   //! Sets the maximum altitude the missile reaches during the climb-out phase
   //! in direct-attack mode.
   virtual void setDirectAttackMaxAltitude(double altitude);
 
   //! \brief Gets the maximum altitude for direct-attack mode
   //! \return The maximum altitude in meters
   //!
   //! Returns the maximum altitude the missile reaches during the climb-out phase
   //! in direct-attack mode.
   virtual double directAttackMaxAltitude() const;
 
   //! \brief Sets the minimum range for direct-attack mode
   //! \param range The minimum range in meters
   //!
   //! Sets the minimum range at which direct-attack mode can be effectively used.
   virtual void setDirectAttackMinRange(double range);
 
   //! \brief Gets the minimum range for direct-attack mode
   //! \return The minimum range in meters
   //!
   //! Returns the minimum range at which direct-attack mode can be effectively used.
   virtual double directAttackMinRange() const;
 
   //! @}
 
   //! \name Common Parameters
   //! @{
 
   //! \brief Sets the maximum range for the missile
   //! \param range The maximum range in meters
   //!
   //! Sets the maximum effective range of the missile, applicable to both
   //! top-attack and direct-attack modes.
   virtual void setMaxRange(double range);
 
   //! \brief Gets the maximum range for the missile
   //! \return The maximum range in meters
   //!
   //! Returns the maximum effective range of the missile, applicable to both
   //! top-attack and direct-attack modes.
   virtual double maxRange() const;
 
   //! @}
 
protected:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is protected and not implemented to prevent
   //! creation of instances without proper initialization.
   DtTopAndDirectAttackMissileControllerDescriptor();
 
protected:
   //! \brief Climb-out angle for top-attack mode
   //!
   //! The angle at which the missile initially climbs during top-attack mode.
   //! Parameter name: "top-attack-climb-out-angle"
   //! Default value: 0.314159 radians (18 degrees)
   DtRwReal myTopAttackClimbOutAngle;
 
   //! \brief Terminal angle for top-attack mode
   //!
   //! The angle at which the missile approaches the target in terminal phase
   //! during top-attack mode.
   //! Parameter name: "top-attack-terminal-angle"
   //! Default value: 0.191986 radians (11 degrees)
   DtRwReal myTopAttackTerminalAngle;
 
   //! \brief Maximum altitude for top-attack mode
   //!
   //! The maximum altitude the missile reaches during altitude-hold phase
   //! in top-attack mode.
   //! Parameter name: "top-attack-max-altitude"
   //! Default value: 150 meters
   DtRwReal myTopAttackMaxAltitude;
 
   //! \brief Minimum range for top-attack mode
   //!
   //! The minimum range at which top-attack mode can be effectively used.
   //! Parameter name: "top-attack-min-range"
   //! Default value: 150 meters
   DtRwReal myTopAttackMinRange;
 
   //! \brief Climb-out angle for direct-attack mode
   //!
   //! The angle at which the missile initially climbs during direct-attack mode.
   //! Parameter name: "direct-attack-climb-out-angle"
   //! Default value: 0.191986 radians (11 degrees)
   DtRwReal myDirectAttackClimbOutAngle;
 
   //! \brief Terminal angle for direct-attack mode
   //!
   //! The angle at which the missile approaches the target in terminal phase
   //! during direct-attack mode.
   //! Parameter name: "direct-attack-terminal-angle"
   //! Default value: 0.0349066 radians (2 degrees)
   DtRwReal myDirectAttackTerminalAngle;
 
   //! \brief Maximum altitude for direct-attack mode
   //!
   //! The maximum altitude the missile reaches during the climb-out phase
   //! in direct-attack mode.
   //! Parameter name: "direct-attack-max-altitude"
   //! Default value: 60 meters
   DtRwReal myDirectAttackMaxAltitude;
 
   //! \brief Minimum range for direct-attack mode
   //!
   //! The minimum range at which direct-attack mode can be effectively used.
   //! Parameter name: "direct-attack-min-range"
   //! Default value: 65 meters
   DtRwReal myDirectAttackMinRange;
 
   //! \brief Maximum range of the missile
   //!
   //! The maximum effective range of the missile, applicable to both
   //! top-attack and direct-attack modes.
   //! Parameter name: "max-range"
   //! Default value: 2500 meters
   DtRwReal myMaxRange;
};
} // namespace makVre