vreLasingMissileTrackController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreLasingMissileTrackController.h
//! \ingroup vreVrfmodel
//! \brief Controller for laser-guided missile tracking with LOAL capability
//!
//! This file defines the DtVreLasingMissileTrackController class which extends
//! the base lasing missile track controller to support "Lock On After Launch" (LOAL)
//! mode by following a designated path before enabling laser tracking.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include <vrfmodel/lasingMissileTrackController.h>
#include "vreVrfmodel/vreSimComponent.h"
 
class DtSimulationServices;
class DtSimMessage;
class DtReflectedDesignator;
class DtLaserTrackerPSR;
class DtVreLasingMissileTrackControllerDescriptor;
 
//! \brief Controller for laser-guided missiles with LOAL capability
//!
//! This controller extends the base laser tracking controller by looking for extended
//! data that defines a path for the missile to follow before enabling laser tracking.
//! This allows the missile to be fired in "Lock On After Launch" (LOAL) mode, where
//! the missile follows a predetermined path until it acquires the laser-designated target.
//! The controller is designed for use with the VRE_Fire_missile lua task and
//! uses the descriptor type DtComponentDescriptor.
namespace makVre
{
//! \brief Type identifier for the VRE lasing missile track controller component
const char DtVreLasingMissileTrackControllerType[] = "vre-lasing-missile-track-controller";
 
class VREVRFMODEL_DLL DtVreLasingMissileTrackController : public DtVreSimComponent<DtLasingMissileTrackController>
{
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtVreLasingMissileTrackController();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtVreLasingMissileTrackController(const DtVreLasingMissileTrackController& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtVreLasingMissileTrackController& operator=(const DtVreLasingMissileTrackController& orig);
 
public:
   //! \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 lasing missile track controller with the specified parameters.
   //! During construction, the controller initializes its internal state to prepare
   //! for missile path tracking.
   DtVreLasingMissileTrackController(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the lasing missile track controller,
   //! including deleting any allocated missile path waypoints.
   virtual ~DtVreLasingMissileTrackController() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtVreLasingMissileTrackControllerType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() 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 Initializes the missile's guidance path
   //!
   //! Parses the "missilePath" extended data to extract waypoints and timing
   //! information for the missile's pre-tracking path. This method also handles
   //! cleanup of any previously defined waypoints to ensure a fresh initialization.
   //! This is called during controller initialization before tracking begins.
   virtual void initializePath();
 
   //! \brief Updates the missile's position along its pre-tracking path
   //! \return True if the missile is still following its path (delaying tracking),
   //!         false if it has completed the path and should begin tracking
   //!
   //! Checks timers to determine if the missile should move on to the next
   //! waypoint in its path. When the path is complete, the missile transitions
   //! to actual laser tracking behavior. This implements the "Lock On After Launch"
   //! functionality that allows the missile to follow a predetermined path
   //! before acquiring the laser-designated target.
   virtual bool updatePath();
 
   //! \brief Sets up the control point for missile guidance
   //! \return True if a valid control point was established, false otherwise
   //!
   //! Overrides the base behavior that tracks a laser spot to incorporate the
   //! "missilePath" extended data functionality. This method is called from the
   //! base class tick() implementation and handles both initializing and updating
   //! the missile's path. Once the initial path is followed, control is handed
   //! over to the standard laser tracking behavior from the base class.
   virtual bool setupControlPoint() override;
 
protected:
   //! \brief Flag indicating whether this is the first control point setup
   //!
   //! When true, indicates that setupControlPoint() has not yet been called,
   //! and the route needs to be initialized. After the first call, this is set
   //! to false to prevent re-initialization.
   bool myFirstSetupControlPoint;
 
   //! \brief Timer tracking how long the missile has been following its current waypoint
   //!
   //! Set to simulation time when the entity started tracking the current waypoint.
   //! Used to determine when to move to the next waypoint in the path.
   double myPathTimer;
 
   //! \brief Collection of waypoints for the missile's pre-tracking path
   //!
   //! Contains pairs of target location vectors and the amount of time (in seconds)
   //! that the missile should track each location before moving to the next waypoint.
   //! When the missile has followed all waypoints, it transitions to laser tracking.
   std::vector<std::pair<DtVector, double>> myDelayedTrackingPoints;
};
} // namespace makVre