vreRlStateRepository.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreRlStateRepository.h
//! \ingroup vreVrfRtd
//! \brief Rotary-wing state repository for VREngage
//!
//! This file defines the DtVreRlStateRepository class, which manages the state
//! information for rotary-wing aircraft in VREngage, including position, orientation,
//! and other simulation state variables.
 
#pragma once
 
#pragma warning(push)
#pragma warning(disable : 4263)
#include <vrfobjcore/rotaryWingEntityStateRepository.h>
#pragma warning(pop)
 
#include <vreVrfRtd/vreRtdBackendLibCommon.h>
 
namespace RlCgfVrf
{
class DtVreRlParameters;
 
//! \brief Type string for VREngage rotary-wing state repository component
//!
//! Constant used to identify this component type in the simulation system.
const char TS_VREngageStateRepository[] = "rotorlib-cgf-vr-engage-state-repository";
//! \brief Rotary-wing aircraft state repository for VREngage
//!
//! This class maintains the state information for rotary-wing aircraft within
//! the VREngage simulation, including position, orientation, velocity, and other
//! aircraft state variables. It provides methods for initializing, updating, and
//! querying this state information.
class RTD_VRF_BACKEND_PLUGIN_EXPORT DtVreRlStateRepository : public DtRotaryWingEntityStateRepository
{
   //! Friend class that needs direct access to state repository internals
   friend class Controller;
 
private:
   //! \brief Copy constructor (not implemented)
   //! \param orig The source object
   DtVreRlStateRepository(const DtVreRlStateRepository& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \param orig The source object
   //! \return Reference to this object
   const DtVreRlStateRepository& operator=(const DtVreRlStateRepository& orig);
 
public:
   //! \brief Constructor
   //! \param vrfObject The local object this repository belongs to
   //! \param name The name of the repository
   //! \param parentRegistry Parent registry for reader/writer functionality
   //!
   //! Initializes a new rotary-wing state repository for VREngage control.
   DtVreRlStateRepository(DtLocalObject* vrfObject, const DtString& name, DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the state repository.
   virtual ~DtVreRlStateRepository() override;
 
   //! \brief Initializes the state repository
   //! \return True if initialization was successful
   //!
   //! Performs initial setup of the state repository, including configuration
   //! loading and state initialization.
   virtual bool init() override;
 
   //! \brief Gets the component type
   //! \return The type string for this component
   //!
   //! Returns TS_VREngageStateRepository as the component type identifier.
   virtual DtString type() const override;
 
   //! \brief Initializes state from parameters
   //!
   //! Sets up the initial state values based on the parameters defined
   //! in the component's descriptor.
   virtual void initializeFromParameters() override;
 
   //! \brief Component factory function
   //! \param name The name for the new repository
   //! \param vrfObject The local object the repository will belong to
   //! \param parentRegistry Parent registry for reader/writer functionality
   //! \return Pointer to the newly created repository
   //!
   //! Static factory function used for component creation through the component registry.
   static DtVrfObjectStateRepository* creator(
      const DtString& name, DtLocalObject* vrfObject, DtReaderWriterRegistry* parentRegistry);
 
   //! \brief Gets the rotary-wing parameters
   //! \return Pointer to the rotary-wing parameters
   //!
   //! Returns the parameters used to configure this rotary-wing aircraft.
   const DtVreRlParameters* getParameters() const;
 
   //! \brief Places the aircraft at a specified location and heading
   //! \param location The position vector where the aircraft should be placed
   //! \param heading The heading (in radians) the aircraft should face
   //! \param clampToGroundFlag If true, adjusts the aircraft altitude to ground level
   //! \param dataAvailable Optional output parameter indicating if terrain data is available
   //! \param requireAllData If true, requires complete terrain data to be available
   //!
   //! Moves the aircraft to the specified location and orientation, optionally
   //! adjusting its altitude to maintain proper ground clearance.
   virtual void place(const DtVector& location,
      const DtReal heading,
      bool clampToGroundFlag = true,
      bool* dataAvailable = 0,
      bool requireAllData = false) override;
};
 
} // namespace RlCgfVrf