ballisticGunJoy.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file ballisticGunJoy.h
//! \ingroup vreVrfmodel
//! \brief Extends the DtBallisticGun class with joystick control capabilities
//!
//! This file defines the DtBallisticGunJoy class which adds joystick control
//! functionality to the base ballistic gun implementation, allowing for manual
//! aiming and firing via joystick input.
 
#pragma once
 
#include "vreVrfmodel/export.h"
 
#include <vrfmodel/ballisticGun.h>
#include <vrfMsgTransport/detonationEvent.h>
 
class DtSimulationServices;
class DtConstrainedAnalogInputPort;
class DtBooleanInputPort;
class DtBallisticGunDescriptor;
 
namespace makVrf
{
class DtArticulatedPartStateRepository;
}
 
namespace makVre
{
const char DtBallisticGunJoyActuatorType[] = "ballistic-gun-joystick-actuator";
 
//! \brief DtBallisticGunJoy extends the DtBallisticGun actuator class with the
//! ability to be controlled from a joystick.
//!
//! Uses Descriptor Type: DtBallisticGunDescriptor
class VREVRFMODEL_DLL DtBallisticGunJoy : public DtBallisticGun
{
public:
   //! \copydoc DtSimComponent(const DtString&,DtLocalObject*,DtSimulationServices*,
   //! DtComponentDescriptor*,DtReaderWriterRegistry* parentRegistry)
   DtBallisticGunJoy(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc, DtReaderWriterRegistry* const parentRegistry = 0);
 
public:
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the ballistic gun joy component.
   virtual ~DtBallisticGunJoy() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtBallisticGunJoyActuatorType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() const override;
 
   //! \brief Creates the input ports for the component
   //! \return True if ports were created successfully, false otherwise
   //!
   //! Creates the elevation and joystick active input ports.
   virtual bool createPorts() override;
 
   //! \brief Sets the component descriptor and extracts configuration values
   //! \param descriptor The component descriptor containing configuration parameters
   //!
   //! Overrides the base class method to extract joystick-specific values and
   //! then calls the base class's method to set common parameters.
   virtual void setComponentDescriptor(DtComponentDescriptor* descriptor) override;
 
   //! \brief Updates the gun state each frame and handles firing
   //!
   //! Performs firing and detonation operations. Detects whether to use local
   //! or parent function based on joystick enable/disable state.
   virtual void tick() override;
 
   //! \brief Sets the target for the gun
   //! \param rotBody The articulated part state repository of the gun, or entity state if none exists
   //! \return Distance to the target, or -1.0 if no target found
   //!
   //! Uses targetSelection() to try to find an entity in the gun's line
   //! of fire; if it finds one, it sets the PSR->currentTarget.
   virtual DtReal setTarget(makVrf::DtArticulatedPartStateRepository* rotBody);
 
   //! \brief Creates a fire interaction event
   //! \param rotBody The articulated part state repository of the gun, or entity state if none exists
   //! \return Pointer to the created fire event
   //!
   //! Creates a fire interaction event. Uses the currentTarget in the PSR as the
   //! fire target, if present.
   virtual makVrfEvents::DtFireEvent* manualFireInteraction(makVrf::DtArticulatedPartStateRepository* rotBody);
 
   //! \brief Creates a detonation interaction event
   //! \param rotBody The articulated part state repository of the gun, or entity state if none exists
   //! \param detTime Reference to store the detonation time
   //! \param dist Distance to the target
   //! \return Pointer to the created detonation event
   //!
   //! Creates a detonation interaction event based on the current target and distance.
   virtual makVrfEvents::DtDetonationEvent* manualDetonationInteraction(
      makVrf::DtArticulatedPartStateRepository* rotBody, DtReal& detTime, DtReal dist);
 
   //! \brief Finds a target along the gun's firing direction
   //! \param rotBody The articulated part state repository of the gun, or entity state if none exists
   //! \param dist Reference to store the distance to the target
   //! \return UUID of the first target found, or empty UUID if none found
   //!
   //! Casts a ray out from the gun to a point MAX_RANGE away (currently 4000m).
   //! Determines, using physicalWorld->getVrfObjectsAlongChord(), if there are any
   //! platforms, lifeforms, or cultural features on the ray. Returns the UUID of
   //! the first one found and stores the range in the dist parameter.
   virtual DtUUID targetSelection(makVrf::DtArticulatedPartStateRepository* rotBody, DtReal& dist);
 
   //! \brief Calculates the distance to the current target
   //! \return Distance to the target, or -1.0 if no target is set
   //!
   //! Determines the distance from the gun to the currently selected target.
   virtual DtReal distanceToTarget();
 
   //! \brief Timer callback for detonation events
   //! \param timer Pointer to the timer that has expired
   //!
   //! Casts the user data portion of the DtTimer to a DtDetonationTimerData object.
   //! Uses the Simulation Manager pointer in the DtDetonationTimerData to get the
   //! DtExerciseConn, and sends the makVrfEvents::DtDetonationEvent via the exercise
   //! connection. The timer is removed from the scheduler, and the
   //! DtDetonationTimerData and makVrfEvents::DtDetonationEvent objects are deleted.
   static void detonationCallback(DtTimer* timer);
 
   //! \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);
 
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtBallisticGunJoy();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtBallisticGunJoy(const DtBallisticGunJoy& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtBallisticGunJoy& operator=(const DtBallisticGunJoy& orig);
 
protected:
   //! \name Ports and Port Groups
   //! @{
 
   //! Input Port Name: elevation\n
   //! Input Port Description: \n
   //! Input Port Range: -1. to 1.\n
   //! Input Port Default Value: \n
   //! Input Group Parent: gun-control
   DtConstrainedAnalogInputPort* myElevationPort;
 
   //! Input Port Name: joystick-active\n
   //! Input Port Description: \n
   //! Input Port Range: \n
   //! Input Port Default Value: \n
   //! Input Group Parent: gun-control
   DtBooleanInputPort* myActiveJoystickPort;
 
   //! @}
 
   //! \brief Flag to track missing articulation warning
   //!
   //! A flag to remember whether a warning message was printed about
   //! not finding an articulated part.
   bool myReportedNoArticulation;
};
} // namespace makVre