vreAimWeaponController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreAimWeaponController.h
//! \ingroup vreVrfmodel
//! \brief Controller for aiming weapons at target points
//!
//! This file defines the DtVreAimWeaponController class which is responsible for
//! controlling the aiming of weapons at specified target points. It supports both
//! AI-controlled and player-controlled aiming behaviors, with special handling for
//! VR controller input.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include <vreVrfmodel/vreSimComponent.h>
#include <vrfModel/aimWeaponController.h>
 
namespace makVrf
{
class DtArticulatedPartStateRepository;
}
 
namespace makVre
{
 
//! \brief Type identifier for the VRE aim weapon controller component
const char DtVreAimWeaponControllerType[] = "vre-aim-weapon-controller";
 
//! \brief Controller for aiming weapons at target points
//!
//! DtVreAimWeaponController is responsible for controlling the aiming of a weapon
//! at a specified target point. It manages the articulated parts of the weapon
//! to ensure proper orientation toward the target. This controller supports both
//! AI-controlled and player-controlled aiming, with special handling for VR input.
//! It also provides functionality for aiming the entity itself when it doesn't
//! have a specific weapon to aim.
//!
//! Uses Descriptor Type: DtAimWeaponControllerDescriptor
class VREVRFMODEL_DLL DtVreAimWeaponController : public DtVreSimComponent<DtAimWeaponController>
{
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 aim weapon controller component with the specified parameters.
   DtVreAimWeaponController(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the aim weapon controller component.
   virtual ~DtVreAimWeaponController() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtVreAimWeaponControllerType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() const override { return DtVreAimWeaponControllerType; }
 
   //! \brief Updates the weapon aiming each simulation frame
   //!
   //! Controls the aiming of the weapon toward its target point. If a player is
   //! acting in the gunner role for this entity, the function returns immediately
   //! to allow player control. Otherwise, it performs AI-controlled aiming with
   //! additional handling for VR controller input. This override also allows aiming
   //! the entity itself even when it doesn't have a dedicated weapon to aim.
   //! Overridden for the following:
   //! * Checks if player is acting in the gunner role for this entity.  If so, returns immediately.
   //! * Contains a fix for yaw aiming using VR controllers.
   //! * Allow aiming the entity itself even if it does not have a weapon to aim.
   virtual void tick() 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 Retrieves the articulated part state repository for the gun
   //! \return Pointer to the articulated part state repository for the gun
   //!
   //! Gets the articulated part state repository that represents the gun part
   //! that this controller is responsible for aiming. This method is used internally
   //! to access the part for applying rotation and aiming adjustments.
   virtual makVrf::DtArticulatedPartStateRepository* getGunPart();
 
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtVreAimWeaponController();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtVreAimWeaponController(const DtVreAimWeaponController& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtVreAimWeaponController& operator=(const DtVreAimWeaponController& orig);
 
protected:
};
 
} // namespace makVre