vreRadarObjectSensor.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreRadarObjectSensor.h
//! \ingroup vreVrfmodel
//! \brief Radar sensor for detecting objects and publishing emitter systems
//!
//! This file defines the DtVreRadarObjectSensor class which extends the radar
//! object sensor to provide enhanced functionality for VR-Engage. It manages
//! radar emitter systems, detection parameters, and designated target tracking.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include <vrfmodel/radarObjectSensor.h>
#include "vreVrfModel/vreSimComponent.h"
 
namespace makVre
{
class DtRadarStateMonitor;
class DtVreRadarObjectSensorDescriptor;
class DtVreRadarObjectSensorPSR;
 
//! \brief Type identifier for the VRE radar object sensor component
const char DtVreRadarObjectSensorType[] = "vre-radar-object-sensor";
 
//! \brief Radar sensor for detecting objects and publishing emitter systems
//!
//! DtVreRadarObjectSensor extends the base radar object sensor to provide
//! enhanced functionality for VR-Engage. It manages radar emitter systems,
//! detection parameters, and designated target tracking. The sensor publishes
//! radar emissions through DIS emitter systems and provides an interface for
//! target designation and tracking.
//!
//! This class serves as a base class for more specialized radar sensor types
//! like the Simple Radar Object Sensor.
class VREVRFMODEL_DLL DtVreRadarObjectSensor : public DtVreSimComponent<DtRadarObjectSensor>
{
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtVreRadarObjectSensor();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtVreRadarObjectSensor(const DtVreRadarObjectSensor& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtVreRadarObjectSensor& operator=(const DtVreRadarObjectSensor& orig);
 
public:
   using DtSignatureObjectSensor::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 object sensor component with the specified parameters.
   DtVreRadarObjectSensor(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the radar object sensor component,
   //! including the radar state monitor and emitter systems.
   virtual ~DtVreRadarObjectSensor() override;
 
   //! \brief Initializes the radar sensor component
   //! \return True if initialization is successful, false otherwise
   //!
   //! Performs component initialization, including setting up the radar
   //! emitter systems, sensor monitors, and attribute providers.
   virtual bool init() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtVreRadarObjectSensorType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() const override;
 
   //! \brief Gets the sensor type identifier
   //! \return Integer identifying the sensor type (DtSensorTypeRadar)
   //!
   //! Returns the sensor type identifier, which is used to categorize
   //! this sensor as a radar sensor type.
   virtual int sensorType() const override;
 
   //! \brief Updates the radar sensor state each simulation frame
   //!
   //! This method handles several radar operations during each tick:
   //! - Turns on the emitter system in the first tick, as indicated in myRadarObjectPsr
   //! - When it's time for the next detection attempt (cached in myRadarObjectPsr),
   //!   calls the base sensor's tick() and computes the time to next detection attempt
   //! - If the entity is destroyed, calls destroyEmitterSystem()
   //! - If the entity has been restored, calls createAndInitEmitterSystem()
   //! - Updates the emitter system's state by calling its tick() method
   virtual void tick() override;
 
   //! \brief Creates and initializes sensor monitors
   //! \return True if monitors were successfully created and initialized, false otherwise
   //!
   //! Creates and initializes the sensor monitors used to communicate with visualization
   //! clients, including the radar state monitor. Overrides the base class implementation.
   virtual bool createAndInitSensorMonitors() override;
 
   //! \brief Creates and initializes the radar settings monitor
   //! \return True if the monitor was successfully created and initialized, false otherwise
   //!
   //! Creates and initializes the radar settings monitor which handles communication
   //! about radar settings between the simulation and visualization clients.
   virtual bool createAndInitRadarSettingsMonitor();
 
   //! \brief Static callback function for radar settings messages
   //! \param msg The simulation message containing radar settings
   //! \param usrData User data pointer, typically pointing to an instance of this class
   //!
   //! Static function registered as a callback to handle radar settings messages.
   //! Forwards the message to the appropriate instance's processSetRadarSettings method.
   static void setRadarSettingsCallback(DtSimMessage* msg, void* usrData);
 
   //! \brief Processes a radar settings message
   //! \param msg The simulation message containing radar settings
   //!
   //! Updates the radar's settings based on the message content. This can include
   //! changes to scan patterns, detection ranges, and other radar parameters.
   virtual void processSetRadarSettings(DtSimMessage* msg);
 
   //! \brief Static callback function for designated target requests
   //! \param usrData User data pointer, typically pointing to an instance of this class
   //! \return Reader/writer containing information about the designated target
   //!
   //! Static function registered as a callback to handle requests for information
   //! about the current designated target. Forwards the request to the appropriate
   //! instance's processProvideDesignatedTarget method.
   static DtReaderWriter* provideDesignatedTargetCallback(void* usrData);
 
   //! \brief Provides information about the currently designated target
   //! \return Reader/writer containing information about the designated target
   //!
   //! Pure virtual method that must be implemented by derived classes to provide
   //! information about the currently designated target. This information is used
   //! by other components to identify which target the radar is currently tracking.
   virtual DtReaderWriter* processProvideDesignatedTarget() = 0;
 
   //! \brief Sets the list of designated targets for the radar
   //! \param trackIds Vector of track IDs to designate
   //!
   //! Pure virtual method that must be implemented by derived classes to set
   //! the designated targets for the radar. The order of track IDs in the vector
   //! may represent their priority, depending on the implementation.
   virtual void setDesignatedTargets(const std::vector<int>& trackIds) = 0;
 
   //! \brief Clears all designated targets from the radar
   //!
   //! Pure virtual method that must be implemented by derived classes to clear
   //! all current target designations. This removes all target designations,
   //! restoring the radar to a standard search/track state.
   virtual void clearDesignatedTargets() = 0;
 
protected:
   //! \brief Updates the radar's detection area based on current settings
   //!
   //! Updates the sensor's geometry evaluator and emitter beam angles according
   //! to the current radar settings. This adjusts the detection capabilities of
   //! the radar based on parameters such as scan pattern, range, and field of view.
   virtual void updateDetectionArea();
 
   //! \brief Registers attribute provider functions
   //!
   //! Registers attribute provider functions with the attribute executive,
   //! including the "designated-target" attribute. These attributes allow
   //! other components to query information about the radar's current state.
   virtual void registerAttributeFunctions() override;
 
   //! \brief Gets the default process state repository type
   //! \return String identifying the default PSR type
   //!
   //! Returns the default process state repository type for this component.
   //! This determines what type of state repository will be created for
   //! storing the radar's persistent state information.
   virtual const char* defaultPSRType() const override;
 
protected:
   //! \brief Pointer to the radar state monitor
   //!
   //! Manages the communication of radar state information between the
   //! simulation and visualization clients. Handles subscription requests
   //! and sends updates when the radar state changes.
   DtRadarStateMonitor* myRadarStateMonitor;
 
   //! \brief Pointer to the radar sensor descriptor
   //!
   //! Contains configuration parameters for the radar sensor, such as
   //! detection ranges, scan patterns, and emitter characteristics.
   const DtVreRadarObjectSensorDescriptor* myRadarObjectDescriptor;
 
   //! \brief Pointer to the radar sensor process state repository
   //!
   //! Contains the persistent state information for the radar sensor,
   //! including current detection settings, scan state, and timing information.
   DtVreRadarObjectSensorPSR* myRadarObjectPsr;
};
 
} // namespace makVre