humanHandWeaponSwitchController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file humanHandWeaponSwitchController.h
//! \ingroup vreVrfmodel
//! \brief Controller that manages handheld weapon switching for human entities
//!
//! This file defines the DtVreHumanHandWeaponSwitchController which manages enabling
//! and disabling secondary weapons for human entities. It addresses compatibility
//! issues with multiple weapons in VRF by disabling secondary weapons when VRF
//! is in control and enabling them when VR Engage is in control.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include "vreVrfmodel/vreSimComponent.h"
#include <vrfobjcore/simComponent.h>
#include <vrfobjcore/componentSystem.h>
 
namespace makVre
{
//! \brief Type identifier for the human handheld weapon switch controller component
const char DtVreHumanHandWeaponSwitchControllerType[] = "handheld-weapon-switcher-controller";
 
//! \brief Controller for managing secondary weapons on human entities
//!
//! DtVreHumanHandWeaponSwitchController manages the enabling and disabling of secondary
//! weapons on human entities. Due to handling limitations in the current version of VRF
//! with multiple weapons, this controller disables secondary weapons when VRF is in
//! control of the entity and enables them when VR Engage is in control.
//!
//! This ensures proper weapon handling while maintaining compatibility between
//! VRF and VR Engage control modes.
class VREVRFMODEL_DLL DtVreHumanHandWeaponSwitchController : public DtVreSimComponent<DtSimComponent>
{
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtVreHumanHandWeaponSwitchController();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtVreHumanHandWeaponSwitchController(const DtVreHumanHandWeaponSwitchController& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtVreHumanHandWeaponSwitchController& operator=(const DtVreHumanHandWeaponSwitchController& 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 Optional component descriptor
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //!
   //! Creates a new human handheld weapon switch controller component with the specified parameters.
   DtVreHumanHandWeaponSwitchController(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Initializes weapon system references before the first tick
   //!
   //! Identifies all weapon systems in the entity by checking for "aimable-weapon"
   //! in the system category. Excludes the first weapon system and stores references
   //! to any additional weapon systems found. These secondary weapons will be managed
   //! based on control state changes.
   virtual void preFirstTickInit() override;
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the human handheld weapon switch controller component.
   virtual ~DtVreHumanHandWeaponSwitchController() override;
 
   //! \brief Updates weapon system states each simulation frame
   //!
   //! Checks whether the entity is player-controlled each frame. When control state changes,
   //! enables or disables secondary weapon systems accordingly. Secondary weapons are enabled
   //! when under VR Engage control and disabled when under VRF control.
   virtual void tick() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtVreHumanHandWeaponSwitchControllerType)
   //!
   //! 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 Component descriptor with configuration parameters
   //! \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);
 
protected:
   //! \brief Collects references to secondary weapon systems
   //!
   //! Scans through all component systems in the entity and identifies those with
   //! the "aimable-weapon" category. Excludes the first weapon system found (primary weapon)
   //! and adds any others to mySystemList for management. In most cases, the secondary
   //! weapon will be a pistol or other sidearm.
   void collectHandheldWeaponSystems();
 
protected:
   //! \brief List of secondary weapon systems to be managed
   //!
   //! Contains pointers to all secondary weapon systems (all but the first)
   //! that have the "aimable-weapon" category.
   std::vector<DtComponentSystem*> mySystemList;
 
   //! \brief Previous player control state
   //!
   //! Tracks whether the entity was player-controlled in the previous frame,
   //! used to detect transitions between control states.
   bool myWasPlayerControlled;
};
} // namespace makVre