vreParachuteActuator.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreParachuteActuator.h
//! \ingroup vreVrfmodel
//! \brief Actuator for parachute simulation
//!
//! This file defines the DtVreParachuteActuator class which provides
//! functionality for simulating parachute behavior including stowed and
//! deployed states, forward movement, steering, and oxygen usage.
#pragma once
 
#include "vreVrfmodel/export.h"
#include "vreVrfmodel/vreSimComponent.h"
 
#include <vrfmodel/parachuteActuator.h>
 
// #include <matrix/LibMatrix.h>
// #include <vlpi/disEnums.h>
// //
// class DtString;
// class DtSimulationServices;
// class DtVrfMovingObjectStateRepository;
// class DtConstrainedAnalogInputPort;
// class DtAnalogInputPort;
// class DtBooleanInputPort;
// class DtInputPortGroup;
// class DtVectorInputPort;
// class DtAnalogOutputPort;
// class DtBooleanOutputPort;
 
namespace makVre
{
class DtVreParachuteActuatorDescriptor;
//    class DtParachuteActuatorPSR;
 
// NOTE-RCH-This is in VRF
//! \brief Type identifier for the VRE parachute actuator component
const char DtVreParachuteActuatorType[] = "vre-parachute-actuator";
 
//! \brief Actuator for simulating parachute behavior in various states
//!
//! DtVreParachuteActuator extends the base parachute actuator to provide
//! VR-Engage specific functionality. It supports both stowed and deployed states,
//! forward movement, steering control, and simulates oxygen consumption at high
//! altitudes or in vehicles with open cargo doors. The actuator manages the
//! physics of parachute deployment and descent.
//!
//! Uses Descriptor Type: DtVreParachuteActuatorDescriptor
class VREVRFMODEL_DLL DtVreParachuteActuator : public DtVreSimComponent<DtParachuteActuator>
{
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 actuator component with the specified parameters.
   DtVreParachuteActuator(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = 0, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the parachute actuator component,
   //! removing process state from process state manager before deleting it.
   virtual ~DtVreParachuteActuator() override;
 
   //! to get access to the entity's localStateRepository, which this component
   //! will update, and then connect to the controller's ports.
   // virtual bool init();
 
   //! \brief Gets the type identifier for this component
   //! \return String identifying the component type (DtVreParachuteActuatorType)
   //!
   //! Implements the DtSimComponent::type() method to return the
   //! type identifier for this component.
   virtual const char* type() const override;
 
   //! \brief Updates the actuator state each simulation frame
   //!
   //! Processes parachute simulation logic each simulation frame, updating
   //! position, orientation, and velocity based on the parachute state (stowed
   //! or deployed). Also handles oxygen usage and updates any hand items.
   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 Simulates oxygen consumption in high-altitude conditions
   //!
   //! Simulates the use of oxygen when the entity is above a certain altitude
   //! and falling, or when inside a vehicle with an open cargo door. This affects
   //! the remaining oxygen supply for the entity, which can impact behavior when
   //! oxygen is depleted.
   virtual void useOxygen();
 
   //! \brief Checks if the cargo door on a specified entity is open
   //! \param entity Reference to the entity to check
   //! \return True if the cargo door is open, false otherwise
   //!
   //! Determines whether the cargo door on the specified entity is in the open
   //! position. This affects oxygen usage when the entity is inside a vehicle.
   virtual bool isCargoDoorOpen(DtSimObjectReference entity) const;
 
   //! \brief Determines if falling behavior should be applied
   //! \param dataAvailable Output parameter indicating if required data is available
   //! \return True if falling behavior should be applied, false otherwise
   //!
   //! Checks various conditions to determine whether falling behavior should
   //! be applied to the entity in the current state. Sets the dataAvailable
   //! parameter to indicate if all required data was available for the check.
   virtual bool checkFallingApplicable(bool& dataAvailable) override;
 
   //! \brief Calculates new orientation based on rotation rates
   //! \param oldLocalOrientation The current orientation matrix
   //! \param newBodyRotationRates The rotation rates in body coordinates
   //! \param newLocalOrientation Output parameter for the new orientation matrix
   //!
   //! Calculates a new orientation matrix based on the previous orientation and
   //! the specified rotation rates. The calculation takes into account the dynamics
   //! of parachute movement and steering inputs.
   virtual void calculateOrientation(
      const DtDcm& oldLocalOrientation, const DtVector& newBodyRotationRates, DtDcm& newLocalOrientation) override;
 
   //! \brief Updates the entity's hand item based on parachute state
   //!
   //! Updates the item in the entity's hands based on the current state of the
   //! parachute (stowed or deployed). This ensures that the entity is visually
   //! represented with the appropriate items during parachute operation.
   virtual void updateHandItem() override;
 
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtVreParachuteActuator();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtVreParachuteActuator(const DtVreParachuteActuator& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtVreParachuteActuator& operator=(const DtVreParachuteActuator& orig);
 
protected:
   //! \brief Pointer to the parachute actuator descriptor
   //!
   //! Contains configuration parameters for the parachute actuator,
   //! such as deployment altitude, descent rate, and steering sensitivity.
   DtVreParachuteActuatorDescriptor* myDescriptor;
 
   //! \brief Name of the property representing the entity's oxygen state
   //!
   //! This constant string holds the property name used to access or update
   //! the oxygen state of the entity within the simulation.
   const std::string myOxygenStatePropertyName = "Oxygen";
 
   //! \brief Last known height of the ground/floor beneath the entity
   //!
   //! Tracks the last known height of the ground or floor beneath the entity,
   //! used for determining landing conditions and altitude-related behaviors.
   double myLastKnownFloorHeight;
};
 
} // namespace makVre