vreTurretFocusController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreTurretFocusController.h
//! \ingroup vreVrfmodel
//! \brief Controller for managing turret focus on specific targets
//!
//! This file defines the DtVreTurretFocusController class which extends
//! the mounting controller to provide functionality for focusing a turret
//! on specific targets. It handles the turret_focus scripted set and manages
//! target tracking.
 
#pragma once
 
#include "vreVrfmodel/export.h"
 
#include "vreVrfmodel/vreSimComponent.h"
 
#include <vrfmodel/mountingController.h>
#include <vrfmodel/scriptEnableController.h>
 
#include <vrfutil/rwUUID.h>
 
namespace makVre
{
//! \brief Type identifier for the turret focus controller component
const char DtVreTurretFocusControllerType[] = "turret-focus-controller";
 
//! \brief Controller for managing turret focus on specific targets
//!
//! DtVreTurretFocusController extends the mounting controller to provide
//! functionality for focusing a turret on specific targets. It processes the
//! turret_focus scripted task set and manages target tracking, allowing turrets
//! to maintain focus on designated targets during movement and engagement.
//! The controller receives target updates and ensures the turret remains
//! pointed at the specified entity.
class VREVRFMODEL_DLL DtVreTurretFocusController : public DtVreSimComponent<DtMountingController>
{
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 turret focus controller component with the specified parameters.
   DtVreTurretFocusController(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = NULL, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the turret focus controller component.
   virtual ~DtVreTurretFocusController() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtVreTurretFocusControllerType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() const override;
 
   //! \brief Initializes the turret focus controller
   //! \return True if initialization is successful, false otherwise
   //!
   //! Registers attribute provider functions and sets up message callbacks for
   //! turret focus control. Called during component creation.
   virtual bool init() override;
 
   //! \brief Updates the turret focus each simulation frame
   //!
   //! Overridden to manage the turret's focus target point. Updates the mounting
   //! controller with the current position of the targeted entity, ensuring the
   //! turret remains pointed at the correct target during simulation.
   virtual void tick() override;
 
   //! \brief Static callback function for turret focus messages
   //! \param msg The simulation message containing focus target information
   //! \param usrData User data pointer, typically pointing to an instance of this class
   //!
   //! Static function registered as a callback to handle turret focus messages.
   //! Forwards the message to the appropriate instance's processSetTurretFocus method.
   static void setTurretFocusCallback(DtSimMessage* msg, void* usrData);
 
   //! \brief Processes a turret focus message
   //! \param msg The simulation message containing focus target information
   //!
   //! Extracts the target entity UUID from the message and updates the controller's
   //! target focus accordingly. This sets the turret to focus on a specific entity.
   virtual void processSetTurretFocus(DtSimMessage* msg);
 
   //! \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, DtReaderWriterRegistry* parentRegistry);
 
private:
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtVreTurretFocusController(const DtVreTurretFocusController& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   DtVreTurretFocusController& operator=(const DtVreTurretFocusController& orig);
 
protected:
   //! \brief UUID of the current target entity
   //!
   //! Stores the unique identifier of the entity that the turret
   //! is currently focused on tracking.
   DtUUID myTargetSimObjectUUID;
};
} // namespace makVre