vreLaserGuidedLauncherController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreLaserGuidedLauncherController.h
//! \ingroup vreVrfmodel
//! \brief Controller for laser-guided launcher systems
//!
//! This file defines the DtVreLaserGuidedLauncherController class which extends
//! the integrated laser guided launcher controller with support for "lock on after
//! launch" functionality. It is designed to be used with the VRE_Fire_Missile lua task.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include <vrfmodel/integratedLaserGuidedLauncherController.h>
#include "vreVrfmodel/vreSimComponent.h"
 
class DtLaserGuidedLauncherControllerDescriptor;
class DtLaserLauncherPSR;
class DtVectorOutputPort;
class DtSimMessage;
 
namespace makVrf
{
class DtLaserDesignatorStateComponent;
}
 
namespace makVre
{
//! \brief Type identifier for the VRE laser guided launcher controller component
const char DtVreLaserGuidedLauncherControllerType[] = "vre-integrated-laser-guided-launcher-controller";
 
//! \brief Controller for managing laser-guided missile systems
//!
//! DtVreLaserGuidedLauncherController extends the base integrated laser guided launcher
//! with support for "lock on after launch" mode. This controller is specifically designed
//! to be used with the VRE_Fire_Missile lua task and supports advanced laser-guided
//! weapon functionality such as post-launch target designation and acquisition.
class VREVRFMODEL_DLL DtVreLaserGuidedLauncherController
   : public DtVreSimComponent<DtIntegratedLaserGuidedLauncherController>
{
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtVreLaserGuidedLauncherController();
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtVreLaserGuidedLauncherController(const DtVreLaserGuidedLauncherController& orig);
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   DtVreLaserGuidedLauncherController& operator=(const DtVreLaserGuidedLauncherController& 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 compDesc Component descriptor with configuration parameters
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //!
   //! Creates a new laser guided launcher controller with the specified parameters.
   DtVreLaserGuidedLauncherController(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* compDesc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the laser guided launcher controller.
   virtual ~DtVreLaserGuidedLauncherController() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtVreLaserGuidedLauncherControllerType)
   //!
   //! 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 Determines if the launcher has permission to fire
   //! \param localSpotPosition The target position in local coordinates
   //! \return True if firing is permitted, false otherwise
   //!
   //! Overridden to check top level tasks for "vre_fire_missile", as Fire at Target is a
   //! subtask when firing as a role player. This allows for proper fire permission checking
   //! in VR-Engage scenarios.
   // virtual bool permissionToFire(const DtVector& localSpotPosition) const override;
};
} // namespace makVre