vreRlParameters.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreRlParameters.h
//! \ingroup vreVrfRtdobjparam
//! \brief Rotary-wing parameters for VREngage
//!
//! This file defines the DtVreRlParameters class, which contains the configuration
//! parameters for rotary-wing aircraft (helicopters) in VREngage. It includes settings
//! for control response, aircraft limits, and simulation fidelity.
 
#pragma once
#include <vreVrfRtdobjparam/export.h>
 
#include <vreVrfRtdobjparam/RTDVRFConfigWarnsForExternalIncludes.h>
RTDVRFConfigWarnsForExternalIncludes()
#include <vrfobjparam/rotaryWingEntityParameters.h>
#pragma warning(pop)
 
   class DtString;
class DtReaderWriterRegistry;
 
namespace RlCgfVrf
{
//! \brief Type string for VREngage rotary-wing parameters
//!
//! Constant used to identify this parameter type in the simulation system.
const char TS_Parameter[] = "rotorlib-cgf-vr-engage-param";
//! \brief Rotary-wing parameters for VREngage
//!
//! This class contains the configuration parameters for rotary-wing aircraft
//! (helicopters) in VREngage. It extends the base rotary-wing entity parameters with
//! VREngage-specific settings for control response, aircraft limits, and
//! simulation fidelity options.
class RTD_VRF_BACKEND_OBJPARAM_DLL DtVreRlParameters : public DtRotaryWingEntityParameters
{
public:
   //! \brief Constructor
   //! \param name The name of the parameters
   //! \param parentRegistry Parent registry for reader/writer functionality
   //! \param env Environment for parameter values
   //! \param objectNode Node containing parameter values
   //!
   //! Initializes a new rotary-wing parameters object with values from the provided environment.
   DtVreRlParameters(const DtString& name = DtString::nullString(), DtReaderWriterRegistry* parentRegistry = NULL,
      DtEnvironmentSP env = DtEnvironmentSP(), DtEnvValueSP* objectNode = NULL);
 
   //! \brief Copy constructor
   //! \param orig The source parameters to copy from
   //! \param name The name for the new parameters
   //! \param parentRegistry Parent registry for reader/writer functionality
   //!
   //! Creates a new parameters object as a copy of the provided original parameters.
   DtVreRlParameters(const DtVreRlParameters& orig, const DtString& name, DtReaderWriterRegistry* parentRegistry);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the parameters object.
   virtual ~DtVreRlParameters() override;
 
   //! \brief Assignment operator
   //! \param orig The source parameters to copy from
   //! \return Reference to this parameters object after assignment
   //!
   //! Assigns the contents of the provided parameters to this parameters object.
   const DtVreRlParameters& operator=(const DtVreRlParameters& orig);
 
   //! \brief Assignment operator from base class
   //! \param orig The source base parameters to copy from
   //! \return Reference to this parameters object after assignment
   //!
   //! Assigns the contents of the provided base parameters to this parameters object.
   const DtVreRlParameters& operator=(const DtRotaryWingEntityParameters& orig);
   //! \brief Creates a clone of these parameters
   //! \param name The name for the cloned parameters
   //! \param parentRegistry Parent registry for reader/writer functionality
   //! \return Pointer to a new parameters object that is a clone of this one
   //!
   //! Creates a new parameters object as a deep copy of this parameters object.
   virtual DtVrfObjectParameters* clone(const DtString& name = DtString::nullString(),
      DtReaderWriterRegistry* parentRegistry = 0) const override;
 
   //! \brief Gets the parameters type
   //! \return The type string for these parameters
   //!
   //! Returns TS_Parameter as the parameters type identifier.
   virtual DtString type() const override;
 
   //! \brief Creator function for this parameter type
   //! \param env Environment for parameter values
   //! \param root Root node containing parameter values
   //! \return Pointer to a new parameters object of this type
   //!
   //! Static factory function used for parameter creation with environment support.
   static DtVrfObjectParameters* creator(DtEnvironmentSP env, DtEnvValueSP* root);
 
   //! \brief Gets the rotorcraft dynamics parameter file path
   //! \return The file path to the rotorcraft dynamics parameters
   //!
   //! Returns the path to the file containing detailed rotorcraft dynamics parameters.
   DtString getVhSimpleRotorcraftParameterFile() const;
 
   //! \brief Gets the altitude offset
   //! \return The altitude offset value
   //!
   //! Returns the altitude offset applied to the helicopter's position.
   DtReal getAltitudeOffset() const;
 
   //! \brief Gets the on-ground tolerance value
   //! \return The on-ground tolerance value
   //!
   //! Returns the tolerance value used to determine if the helicopter is on the ground.
   //! This affects landing behavior and ground effect simulation.
   DtReal getOnGroundTolerance() const;
 
   //! \brief Gets whether high-fidelity terrain queries are enabled
   //! \return True if high-fidelity terrain queries are enabled, false otherwise
   //!
   //! Returns whether high-fidelity terrain queries are enabled for this helicopter.
   DtBoolean getHighFidelityTerrainQueries() const;
 
   //! \brief Gets the maximum altitude limit
   //! \return Reference to the maximum altitude value
   //!
   //! Returns the maximum altitude limit for the helicopter.
   const DtRwReal& getMaxAltitude() const { return myMaxAltitude; }
 
   //! \brief Gets the maximum speed limit
   //! \return Reference to the maximum speed value
   //!
   //! Returns the maximum speed limit for the helicopter.
   const DtRwReal& getMaxSpeed() const { return myMaxSpeed; }
 
   //! \brief Inherits values from another parameters object
   //! \param benefactor The parameters object to inherit from
   //! \return True if values were successfully inherited, false otherwise
   //!
   //! Inherits values from another parameters object, if it is of a compatible type.
   virtual bool inheritValues(const DtVrfObjectParameters* benefactor) override;
 
   //! \brief Inherits values from another parameters object of the same type
   //! \param pars The parameters object to inherit from
   //!
   //! Inherits values from another parameters object of the same type.
   virtual void inheritValuesFromThisType(const DtVreRlParameters* pars);
 
protected:
   //! \brief Initial desired speed value
   //!
   //! The initial desired speed for the helicopter upon activation.
   DtRwReal myInitialDesiredSpeed;
 
   //! \brief Initial desired altitude value
   //!
   //! The initial desired altitude for the helicopter upon activation.
   DtRwReal myInitialDesiredAltitude;
 
   //! \brief Altitude offset value
   //!
   //! Offset applied to the helicopter's altitude.
   DtRwReal myAltitudeOffset;
 
   //! \brief On-ground tolerance value
   //!
   //! Tolerance value used to determine if the helicopter is on the ground.
   //! This affects landing behavior and ground effect simulation.
   DtRwReal myOnGroundTolerance;
 
   //! \brief Flag for high-fidelity terrain queries
   //!
   //! When true, high-fidelity terrain queries are used for this helicopter.
   DtRwBoolean myHighFidelityTerrainQueries;
 
private:
   //! \brief File path to the rotorcraft dynamics parameters
   //!
   //! Path to the file containing detailed rotorcraft dynamics parameters.
   DtRwString myRotorcraftParameterFile;
};
 
} // namespace RlCgfVrf