ballisticGunJoyController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file ballisticGunJoyController.h
//! \ingroup vreVrfmodel
//! \brief Controller for ballistic guns with joystick input support
//!
//! This file defines the DtBallisticGunJoyController class which extends the standard
//! ballistic gun controller with joystick input capabilities, allowing manual control
//! of weapon aiming and firing.
 
#pragma once
 
#include "vreVrfmodel/export.h"
 
#include <vrfmodel/ballisticGunController.h>
#include <vrfmodel/joystickControllerInterface.h>
 
class DtConstrainedAnalogOutputPort;
class DtBooleanOutputPort;
class DtOutputPortGroup;
class DtJoyDeviceControllerDescriptor;
 
//! \brief Type identifier for the ballistic gun joy controller component
const char DtBallisticGunJoyControllerType[] = "ballistic-gun-joy-controller";
 
namespace makVre
{
//! \brief Controller for ballistic guns with joystick input capabilities
//!
//! DtBallisticGunJoyController extends the DtBallisticGunController class
//! with the ability to be controlled from a joystick. It implements the
//! DtJoystickControllerInterface to process joystick input and translate
//! it to appropriate gun control outputs.
//!
//! Uses Descriptor Type: DtBallisticGunJoyControllerDescriptor
class VREVRFMODEL_DLL DtBallisticGunJoyController : public DtBallisticGunController,
                                                    public DtJoystickControllerInterface
{
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 ballistic gun joy controller component with the specified parameters.
   DtBallisticGunJoyController(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc, DtReaderWriterRegistry* const parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the ballistic gun joy controller component.
   virtual ~DtBallisticGunJoyController() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtBallisticGunJoyControllerType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() const override;
 
   //! \brief Creates the joystick active state output port
   //! \return True if port was created successfully, false otherwise
   //!
   //! Creates the output port used to indicate when joystick control is active.
   //! This is called during initialization to set up communication with the actuator.
   virtual bool createActiveJoystickPort();
 
   //! \brief Gets the joystick active state output port
   //! \return Pointer to the joystick active output port
   //!
   //! Provides access to the port that indicates when joystick control is active.
   virtual DtBooleanOutputPort* activeJoystickPort() const;
 
   //! \brief Creates the elevation control output port
   //! \return True if port was created successfully, false otherwise
   //!
   //! Creates the output port used to control gun elevation via joystick input.
   virtual bool createElevationPort();
 
   //! \brief Gets the elevation control output port
   //! \return Pointer to the elevation output port
   //!
   //! Provides access to the port that controls gun elevation.
   virtual DtConstrainedAnalogOutputPort* elevationPort() const;
 
   //! \brief Selects ammunition type for the weapon
   //! \param name The entity type of ammunition to select, or null for default
   //! \return True if ammunition selection was successful, false otherwise
   //!
   //! Attempts to select the specified ammunition type for the weapon.
   //! If no type is specified (nullType), uses the default ammunition.
   virtual bool chooseAmmo(const DtEntityType& name = DtEntityType::nullType());
 
   //! \brief Checks if the weapon can currently fire
   //! \return True if the weapon can fire, false otherwise
   //!
   //! Determines whether the weapon is currently able to fire based on
   //! ammunition availability and other weapon state conditions.
   virtual bool canFire();
 
   //! \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 Updates the controller state each simulation frame
   //!
   //! Processes joystick input and updates output ports to control
   //! the associated ballistic gun actuator component.
   virtual void tick() override;
 
   //! \brief Processes joystick input and updates output ports
   //! \param functionGroup The function group identifier for the input
   //! \param function The specific function identifier within the group
   //! \param value The input value from the joystick
   //! \param repeat Flag indicating if this is a repeated input
   //!
   //! Implements the DtJoystickControllerInterface method to process joystick
   //! input and update the controller's output ports accordingly.
   virtual void calcAndSetPortValues(
      const DtString& functionGroup, const DtString& function, double value, bool repeat) override;
   //! \brief Handles joystick connection event
   //!
   //! Called when a joystick is connected to the system.
   //! Activates joystick control mode for this controller.
   virtual void joystickConnected() override;
   //! \brief Handles joystick disconnection event
   //!
   //! Called when a joystick is disconnected from the system.
   //! Deactivates joystick control mode for this controller.
   virtual void joystickDisconnected() override;
 
   //! \brief Creates all required output ports for this controller
   //! \return True if all ports were created successfully, false otherwise
   //!
   //! Overridden to create the specific output ports needed by this controller,
   //! including elevation control and joystick active state ports.
   virtual bool createPorts() override;
 
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtBallisticGunJoyController();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtBallisticGunJoyController(const DtBallisticGunJoyController& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtBallisticGunJoyController& operator=(const DtBallisticGunJoyController& orig);
 
protected:
   //! \name Ports and Port Groups
   //! @{
 
   //! Output Port Name: elevation\n
   //! Output Port Description: \n
   //! Output Port Range: -1. to 1.\n
   //! Output Port Default Value: \n
   //! Output Group Parent:
   DtConstrainedAnalogOutputPort* myElevationPort;
 
   //! Output Port Name: joystick-active\n
   //! Output Port Description: Indicates whether controller behavior is being
   //! executed through a joystick.\n
   //! Output Port Range: \n
   //! Output Port Default Value: false\n
   //! Output Group Parent:
   DtBooleanOutputPort* myActiveJoystickPort;
 
   //! @}
 
   //! \brief Flag indicating if the weapon is currently firing
   bool myFiring;
 
   //! \brief Flag indicating if the fire button is currently pressed
   bool myFireButtonDown;
};
} // namespace makVre