vreLasingController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreLasingController.h
//! \ingroup vreVrfmodel
//! \brief Controller for laser designation functionality
//!
//! This file defines the DtVreLasingController class which extends the base
//! lasing controller to support VR-Engage specific laser designation features.
//! It sets a state property "HasLaser" defined in human and aircraft platform files,
//! allowing the VRE player menu to show laser designation options.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include "vreVrfmodel/vreSimComponent.h"
 
#include <vreMessageManager/vreMessage.h>
 
#include <vrfmodel/lasingController.h>
 
//! \brief Derived laser controller with VR-Engage specific functionality
//!
//! This controller extends the base lasing controller and sets a state property - "HasLaser"
//! that is defined in the Human and flying aircraft sysdef platform files. By doing so,
//! the VR-Engage player menu will know that it should show the laser designation options.
//! It is connected to GUI definitions in sensorOperator.lua & human.lua, and is designed for
//! use with the Set_Lase_Location lua task set.
namespace makVre
{
//! \brief Type identifier for the VRE lasing controller component
const char DtVreLasingControllerType[] = "vre-laser-controller";
 
class VREVRFMODEL_DLL DtVreLasingController : public DtVreSimComponent<DtLasingController>
{
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtVreLasingController();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtVreLasingController(const DtVreLasingController& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtVreLasingController& operator=(const DtVreLasingController& 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 controller component with the specified parameters.
   DtVreLasingController(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the lasing controller component.
   virtual ~DtVreLasingController() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtVreLasingControllerType)
   //!
   //! 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
   //!
   //! Gets initial laser designator code from the Process State Repository (PSR)
   //! and copies it to the state property "laserCode". This ensures that the
   //! GUI displays the correct laser code when the simulation starts.
   virtual void preFirstTickInit() override;
 
   //! \brief Updates the controller state each simulation frame
   //!
   //! Processes lasing operations during each simulation frame. This includes
   //! updating laser position, checking line of sight conditions, and managing
   //! the lasing state based on player inputs.
   virtual void tick() override;
 
   //! \brief Initializes the lasing controller
   //! \return True if initialization is successful, false otherwise
   //!
   //! Sets the state property named "HasLaser" to True. This property is defined
   //! in the platform sysdef file under state-data and is used by the VR-Engage menu
   //! system to determine whether to show laser designation options in the user interface.
   virtual bool init() 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);
 
   //! \brief Callback for entity restoration events
   //! \param msg The message containing restoration information
   //! \param usrData User data pointer, typically pointing to the instance of this class
   //!
   //! Static callback function invoked when an entity is restored. This function forwards
   //! the message to the instance's processSetRestore method to reinitialize state properties.
   static void setRestoreCallback(DtSimMessage* msg, void* usrData);
 
protected:
   //! \brief Handles messages to start lasing at a specific location
   //! \param msg The message containing lasing parameters
   //! \return Message processing result indicating success or failure
   //!
   //! Processes StartLasingLocation messages, which activate the laser designator
   //! at a specified location. This allows the entity to designate targets for
   //! laser-guided weapons.
   virtual makVre::DtVreMessageResult handleStartLasingLocation(makVre::DtVreMessage* msg);
 
   //! \brief Handles messages to stop lasing
   //! \param msg The message containing stop lasing request
   //! \return Message processing result indicating success or failure
   //!
   //! Processes StopLasingLocation messages, which deactivate the laser designator.
   //! This turns off the laser and stops target designation.
   virtual makVre::DtVreMessageResult handleStopLasingLocation(makVre::DtVreMessage* msg);
 
   //! \brief Handles messages to set a new lasing location
   //! \param msg The message containing new lasing location parameters
   //! \return Message processing result indicating success or failure
   //!
   //! Processes SetLasingLocation messages, which update the location
   //! at which the laser designator is pointing. This allows for tracking
   //! moving targets or switching designation to a new target.
   virtual makVre::DtVreMessageResult handleSetLasingLocation(makVre::DtVreMessage* msg);
 
   //! \brief Processes entity restoration messages
   //! \param msg The message containing restoration information
   //!
   //! Reinitializes the state property "HasLaser" when a set restore operation
   //! is executed. This ensures that the entity's laser capabilities are properly
   //! restored after entity restoration, allowing the VR-Engage menu to correctly
   //! display laser options.
   virtual void processSetRestore(DtSimMessage* msg);
 
   //! \brief Processes laser code change requests
   //! \param msg The message containing the new laser code
   //!
   //! Sets the state property for laser code based on the message contents,
   //! so the updated code can be reflected in the GUI. This allows users to
   //! change laser codes through the user interface, ensuring that laser-guided
   //! weapons are properly configured for the selected code.
   virtual void processSetLaserCodeRequestMessage(DtSimMessage* msg) override;
 
   //! \brief Determines if the controller has line of sight to a target
   //! \param target Reference to the target object
   //! \param reason Output parameter that will contain the reason for line of sight failure
   //! \return True if line of sight exists, false otherwise
   //!
   //! Checks whether the laser controller has line of sight with the specified target.
   //! Overridden to demote an excessive warning in the console (changed from DtWarn to
   //! DtVerbose level). The actual line of sight calculation functionality remains
   //! unchanged from the base class implementation.
   virtual bool lineOfSight(DtSimObjectReference target, DtString& reason) override;
 
   //! \brief Flag indicating whether the player is currently lasing
   //!
   //! When true, indicates that the player has activated the laser designator
   //! and is currently designating a target. This state affects various controller
   //! behaviors including message handling and visual effects.
   bool myPlayerIsLasing;
};
} // namespace makVre