vreParachuteController.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreParachuteController.h
//! \ingroup vreVrfmodel
//! \brief Controller for parachute steering and deployment
//!
//! This file defines the DtVreParachuteController class which extends
//! the base parachute controller to add joystick control capabilities for
//! steering and deploying parachutes.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include "vreVrfmodel/vreSimComponent.h"
 
#include <vrfmodel/parachuteController.h>
#include <vrfmodel/joystickControllerInterface.h>
 
namespace makVre
{
//! \brief Type identifier for the VRE parachute controller component
const char* DtVreParachuteControllerType = "vre-parachute-controller";
 
//! \brief Controller for parachute operation with joystick input support
//!
//! DtVreParachuteController extends the base parachute controller to add joystick
//! control capabilities. This allows direct user control of parachute steering and
//! deployment through joystick inputs. The controller also provides automated
//! guidance for CGF entities to navigate to designated landing locations.
//!
//! Uses Descriptor Type: DtParachuteControllerDescriptor
class VREVRFMODEL_DLL DtVreParachuteController : public DtVreSimComponent<DtParachuteController>,
                                                 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 parachute controller component with the specified parameters.
   DtVreParachuteController(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the parachute controller component.
   //! This is mostly a no-op as the component doesn't maintain many resources.
   virtual ~DtVreParachuteController() override;
 
   //! \brief Updates the controller state each simulation frame
   //!
   //! Handles CGF (Computer Generated Forces) control of steering and
   //! parachute deployment. For non-player entities, calculates the appropriate
   //! steering inputs to guide the entity toward its designated landing location.
   virtual void tick() override;
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtVreParachuteControllerType)
   //!
   //! 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 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 Projects the expected landing location of an entity
   //! \param entity Reference to the entity to project landing location for
   //! \return The projected landing location as a 3D vector
   //!
   //! Calculates the expected landing location of a parachuting entity based on
   //! its current position, velocity, and environmental factors such as wind.
   //! This is used for both visualization and to guide autonomous entities toward
   //! their intended landing zones.
   virtual DtVector projectLandingLocation(DtSimObjectReference entity);
 
   //! \brief Processes joystick input and sets corresponding port values
   //! \param functionGroup The function group identifier for the input
   //! \param function The specific function name for the input
   //! \param value The input value (typically in range [-1.0, 1.0])
   //! \param repeat Flag indicating whether the function should repeat
   //!
   //! Handles joystick input by translating joystick function calls into
   //! appropriate parachute control values. Maps joystick axes and buttons
   //! to steering and deployment controls for the parachute.
   virtual void calcAndSetPortValues(
      const DtString& functionGroup, const DtString& function, double value, bool repeat) override;
 
   //! \brief Handles joystick connection events
   //!
   //! Required by the DtJoystickControllerInterface, but currently a no-op.
   //! Called when a joystick is connected to the system.
   virtual void joystickConnected() override;
 
   //! \brief Handles joystick disconnection events
   //!
   //! Required by the DtJoystickControllerInterface, but currently a no-op.
   //! Called when a joystick is disconnected from the system.
   virtual void joystickDisconnected() override;
 
   //! \brief Processes parachute-to-location task messages
   //! \param msg The simulation message containing task parameters
   //!
   //! Overridden to fix a task parameter name mismatch. The incorrect capitalization
   //! in the method name ("Tolocation" instead of "ToLocation") is maintained to
   //! match the base class implementation for compatibility purposes.
   virtual void processParachuteTolocationTask(DtSimMessage* msg) override;
 
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtVreParachuteController();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtVreParachuteController(const DtVreParachuteController& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtVreParachuteController& operator=(const DtVreParachuteController& orig);
};
 
} // namespace makVre