radarWarningReceiverDescriptor.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file radarWarningReceiverDescriptor.h
//! \ingroup vreVrfobjparam
//! \brief Radar Warning Receiver (RWR) descriptor for VREngage
//!
//! This file defines the DtRadarWarningReceiverDescriptor class, which configures
//! Radar Warning Receiver components in VREngage. RWR systems detect and classify radar
//! emissions, providing essential threat detection for military aircraft and vehicles.
 
#pragma once
 
#include "vreVrfobjparam/export.h"
#include <vrfobjparam/componentDescriptor.h>
#include <readerWriter/rwReal.h>
 
namespace makVre
{
//! \brief Type identifier string for the Radar Warning Receiver descriptor
const char DtRadarWarningReceiverDescriptorType[] = "vre-radar-warning-receiver-descriptor";
 
//! \brief Radar Warning Receiver (RWR) descriptor for VREngage
//!
//! This class defines a descriptor for the Radar Warning Receiver component,
//! which allows entities to detect radar emissions from other entities in the
//! simulation. It provides configuration for detection periods, ranges, and other
//! parameters that control how radar emissions are detected and classified.
class VREVRFOBJPARAM_DLL DtRadarWarningReceiverDescriptor : public DtComponentDescriptor
{
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtRadarWarningReceiverDescriptor();
 
public:
   //! \brief Constructor with component name
   //! \param name The name of this component
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //!
   //! Creates a new Radar Warning Receiver descriptor with the specified name.
   DtRadarWarningReceiverDescriptor(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Copy constructor
   //! \param orig The source descriptor to copy from
   //! \param parentRegistry Parent registry for reader/writer functionality (optional)
   //!
   //! Creates a new Radar Warning Receiver descriptor as a copy of the provided original.
   DtRadarWarningReceiverDescriptor(
      const DtRadarWarningReceiverDescriptor& orig, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \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.
   DtRadarWarningReceiverDescriptor& operator=(const DtRadarWarningReceiverDescriptor& orig);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the descriptor.
   virtual ~DtRadarWarningReceiverDescriptor() 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 DtRadarWarningReceiverDescriptorType.
   virtual DtString type() const override;
 
   //! \brief Gets the detection period
   //! \return The detection period in seconds
   //!
   //! Returns the time between checks for new radar emitters.
   virtual DtReal detectionPeriod() const;
 
   //! \brief Sets the detection period
   //! \param detectionPeriod The detection period in seconds
   //!
   //! Sets the time between checks for new radar emitters.
   virtual void setDetectionPeriod(DtReal detectionPeriod);
 
   //! \brief Gets the detection period variance
   //! \return The detection period variance in seconds
   //!
   //! Returns the magnitude of random variance added to the detection period.
   virtual DtReal detectionPeriodVariance() const;
 
   //! \brief Sets the detection period variance
   //! \param detectionPeriodVariance The detection period variance in seconds
   //!
   //! Sets the magnitude of random variance added to the detection period.
   virtual void setDetectionPeriodVariance(DtReal detectionPeriodVariance);
 
   //! \brief Sets the emitter detection range
   //! \param range The maximum detection range in meters
   //!
   //! Sets the maximum range at which radar emitters can be detected.
   virtual void setEmitterDetectionRange(double range);
 
   //! \brief Gets the emitter detection range
   //! \return The maximum detection range in meters
   //!
   //! Returns the maximum range at which radar emitters can be detected.
   virtual double emitterDetectionRange() const;
 
   //! \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 Radar Warning Receiver descriptor as a deep copy of this one.
   virtual DtComponentDescriptor* clone(DtReaderWriterRegistry* parentRegistry = 0) 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.
   static DtComponentDescriptor* creator();
 
   //! \brief Gets configuration data for this descriptor from script arguments
   //! \param args Script arguments to process
   //! \param searchPaths Search paths for resolving file references
   //! \param variableBindings Variable bindings for resolving script variables
   //!
   //! Processes script arguments to configure this descriptor instance.
   virtual void getSelf(DtlObjPtr args,
      const DtReaderWriter::SearchPaths& searchPaths,
      const DtVariableBindingsList& variableBindings) override;
 
protected:
   //! \name Configuration Parameters
   //! These parameters are available for setting in the OPD files.
   //@{
   //! \brief Time between radar emission detection checks
   //!
   //! The time interval between consecutive checks for new radar emitters or the
   //! removal of previously detected emitters. If an emitter has a 1 in 10 chance
   //! of being detected in each detection period, and the detection period is 1 second,
   //! then the emitter can be expected to be detected within 10 seconds on average.
   //!
   //! Default value: 1.0
   //! Units: seconds
   DtRwReal myDetectionPeriod;
 
   //! \brief Random variance for detection period timing
   //!
   //! Magnitude of random variance added to the detection period to spread
   //! checks out over different simulation ticks. This helps prevent synchronized
   //! detection patterns and creates more realistic detection behavior.
   //!
   //! Default value: 0.0
   //! Units: seconds
   DtRwReal myDetectionPeriodVariance;
 
   //! \brief Maximum detection range for radar emitters
   //!
   //! The maximum distance at which this Radar Warning Receiver can detect
   //! radar emissions from other entities. Emissions beyond this range will
   //! not be detected regardless of their power or characteristics.
   //!
   //! Default value: 5000.0
   //! Units: meters
   DtRwReal myEmitterDetectionRange;
 
   //@}
};
} // namespace makVre