radarWarningReceiver.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file radarWarningReceiver.h
//! \ingroup vreVrfmodel
//! \brief Radar Warning Receiver component
//!
//! This file defines the DtRadarWarningReceiver class which provides common functionality
//! for Radar Warning Receiver systems. It detects and tracks radar signals targeting the
//! entity, and communicates this information to visualization systems through a monitor.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include <vrfobjcore/simComponent.h>
#include <vreMessageManager/vreMessageManager.h>
 
namespace makVre
{
class DtRwrMonitor;
 
//! \brief Type identifier for the VRE radar warning receiver component
const char DtVreRadarWarningReceiverType[] = "vre-radar-warning-receiver";
 
class DtRadarWarningReceiverPSR;
class DtRadarWarningReceiverDescriptor;
 
//! \brief Component for detecting and tracking radar signals targeting the entity
//!
//! DtRadarWarningReceiver provides the functionality needed to detect and track
//! radar signals that are targeting the entity. It maintains a list of detected
//! radar emitters, their signal characteristics, and threat levels. The component
//! communicates with visualization systems through a monitor to provide up-to-date
//! threat information to the user interface.
//!
//! Uses Descriptor Type: DtRadarWarningReceiverDescriptor
class VREVRFMODEL_DLL DtRadarWarningReceiver : public DtSimComponent
{
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtRadarWarningReceiver();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtRadarWarningReceiver(const DtRadarWarningReceiver& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtRadarWarningReceiver& operator=(const DtRadarWarningReceiver& orig);
 
public:
   using DtSimComponent::tick;
 
   //! \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 radar warning receiver component with the specified parameters.
   DtRadarWarningReceiver(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the radar warning receiver component,
   //! including the monitor and process state repository.
   virtual ~DtRadarWarningReceiver() override;
 
   //! \brief Initializes the radar warning receiver component
   //! \return True if initialization is successful, false otherwise
   //!
   //! Performs component initialization, including creating the process
   //! state repository (PSR) by calling createPSR().
   virtual bool init() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtVreRadarWarningReceiverType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() const override;
 
   //! \brief Performs initialization before the first simulation tick
   //!
   //! Performs one-time setup tasks that must be completed before the first
   //! simulation tick, such as initializing the RWR monitor.
   virtual void preFirstTickInit() override;
 
   //! \brief Updates the component state each simulation frame
   //!
   //! Processes radar signal detection logic each simulation frame,
   //! updating the list of detected emitters and their threat levels.
   //! Also handles communication with the monitor for visualization.
   virtual void tick() override;
 
   //! \brief Handles messages to enable or disable the RWR
   //! \param msg The message containing enable/disable request
   //! \return Message processing result indicating success or failure
   //!
   //! Processes messages that request changing the enabled state of
   //! the radar warning receiver.
   virtual DtVreMessageResult handleRwrSetEnabledMessage(DtVreMessage* msg);
 
   //! \brief Determines if this component should tick while the entity is destroyed
   //! \return Always returns true for RWR components
   //!
   //! The radar warning receiver continues to tick even when the entity is destroyed
   //! so that it can notify any subscribed GUIs that it is no longer detecting
   //! objects. This ensures proper cleanup of visualization displays.
   virtual bool tickWhileDestroyed() const 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);
 
protected:
   //! \brief Creates input and output port groups for the component
   //! \return True if port groups were created successfully, false otherwise
   //!
   //! Creates and initializes the port groups used by this component
   //! for receiving and transmitting data related to radar warnings.
   virtual bool createPortGroups() override;
 
   //! \brief Creates input and output ports for the component
   //! \return True if ports were created successfully, false otherwise
   //!
   //! Creates the target list port and any other ports needed by the
   //! radar warning receiver to communicate with other components.
   virtual bool createPorts() override;
 
   //! \brief Creates the process state repository for the component
   //! \return Pointer to the created process state repository
   //!
   //! Creates the myProcessState data member and adds it to the process state
   //! repository manager. Uses the name and type specified in the component
   //! descriptor (if they exist) or appropriate defaults if not specified.
   //! The PSR maintains the state of detected radar emitters and their properties.
   virtual DtRadarWarningReceiverPSR* createPSR();
 
   //! \brief Gets the default process state repository type
   //! \return String identifying the default PSR type (DtVrfRwrProcessStateRepositoryType)
   //!
   //! Returns the default process state repository type for this component.
   //! Derived classes may override this to return their own default PSR type
   //! if a different PSR type is desired.
   virtual const char* defaultPSRType() const;
 
   //! \brief Creates and initializes the RWR monitor
   //! \return True if monitor creation and initialization succeeds, false otherwise
   //!
   //! Creates a DtRwrMonitor instance and initializes it, establishing the
   //! connection between the radar warning receiver and the front-end
   //! visualization system for displaying radar warning information.
   virtual bool createAndInitRwrMonitor();
 
protected:
   //! \brief Pointer to the radar warning receiver process state repository
   //!
   //! Maintains state information about detected radar emitters, their
   //! properties, and threat levels. This state persists across simulation
   //! ticks and can be saved with scenarios.
   DtRadarWarningReceiverPSR* myProcessState;
 
   //! \brief Pointer to the component descriptor
   //!
   //! Contains configuration parameters for the radar warning receiver,
   //! such as detection ranges, frequency bands, and visualization settings.
   const DtRadarWarningReceiverDescriptor* myRwrDescriptor;
 
   //! \brief Pointer to the RWR monitor
   //!
   //! Handles communication with visualization clients, sending RWR contact
   //! information to the GUI or other applications that have requested the
   //! information. Maintains subscription lists and message handling.
   DtRwrMonitor* myMonitor;
};
 
} // namespace makVre