vortexInterface.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2024 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file    vortexInterface.h
//! \brief   Provides interface functionality between VR-Forces and the Vortex physics engine
//! \ingroup vreVrfVortex
 
#pragma once
 
#include <vreVrfVortex/export.h>
 
#include <VxSim/VxSmartInterface.h>
#include <VxSim/VxVHLInterface.h>
 
#include <vector>
 
namespace makVre
{
class DtVortexInterfaceDescriptor;
}
 
class DtInputPortGroup;
class DtOutputPortGroup;
class DtSingleConnectionInputPort;
class DtSingleConnectionOutputPort;
class DtVrfObjectStateRepository;
 
namespace VxData
{
class FieldBase;
}
 
namespace VxSim
{
class VxExtension;
class VxPluginExtension;
class VxVHLInterface;
class VxSimulationState;
} // namespace VxSim
 
//! \brief Base class for Vortex interface elements
//!
//! Provides a common interface for all Vortex interface elements, allowing for
//! type-agnostic handling of different port types.
class VREVRFVORTEX_DLL DtVortexInterfaceBaseElement
{
public:
   //! \brief Default constructor
   DtVortexInterfaceBaseElement() {}
 
   //! \brief Virtual destructor
   //!
   //! Ensures proper cleanup of derived classes.
   virtual ~DtVortexInterfaceBaseElement() {}
 
   //! \brief Updates the interface element
   //!
   //! Pure virtual function that must be implemented by derived classes
   //! to handle data transfer between ports and Vortex fields.
   virtual void update() = 0;
 
   //! \brief Gets the port name
   //!
   //! \return The name of the port
   virtual std::string portName() = 0;
 
   //! \brief Gets the field name
   //!
   //! \return The name of the field
   virtual std::string getFieldName() = 0;
 
   //! \brief Sets the Vortex field associated with this element
   //!
   //! \param field Pointer to the Vortex field
   virtual void setField(VxData::FieldBase* field) = 0;
};
 
//---------------------------------------------------------------------------------------------------------------------
 
//! \brief Template class for Vortex interface elements
//!
//! Implements the DtVortexInterfaceBaseElement interface for specific port types.
//! Handles the connection between VR-Forces ports and Vortex fields.
template <typename T>
class VREVRFVORTEX_DLL DtVortexInterfaceElement : public DtVortexInterfaceBaseElement
{
public:
   //! \brief Constructor
   //!
   //! Creates and initializes the port with the specified names.
   //!
   //! \param portName Name of the port
   //! \param vortexName Name of the Vortex field
   DtVortexInterfaceElement(std::string portName, const std::string& vortexName);
 
   //! \brief Destructor
   //!
   //! Cleans up resources.
   virtual ~DtVortexInterfaceElement() override;
 
   //! \brief Updates the interface element
   //!
   //! Transfers data between the port and the Vortex field.
   //! The implementation of this method is specialized for different port types.
   virtual void update() override;
 
   //! \brief Gets the port
   //!
   //! Provides access to the underlying port object.
   //!
   //! \return Pointer to the port
   T* port() { return myPort; }
 
   //! \brief Sets the Vortex field
   //!
   //! Associates a Vortex field with this interface element.
   //!
   //! \param field Pointer to the Vortex field
   virtual void setField(VxData::FieldBase* field) override;
 
   //! \brief Gets the Vortex field
   //!
   //! \return Pointer to the Vortex field
   VxData::FieldBase* getField() const;
 
   //! \brief Gets the port name
   //!
   //! \return The name of the port
   virtual std::string portName() override;
 
   //! \brief Gets the field name
   //!
   //! \return The name of the field
   virtual std::string getFieldName() override;
 
protected:
   T* myPort;                        //!< Pointer to the port
   VxData::FieldBase* myVortexField; //!< Pointer to the Vortex field
   std::string myPortName;           //!< Name of the port
   std::string myFieldName;          //!< Name of the field
};
 
//! \brief Gets the field name
//!
//! \return The name of the field
template <typename T>
std::string DtVortexInterfaceElement<T>::getFieldName()
{
   return myFieldName;
}
 
//! \brief Gets the port name
//!
//! \return The name of the port
template <typename T>
std::string DtVortexInterfaceElement<T>::portName()
{
   return myPortName;
}
 
//! \brief Gets the Vortex field
//!
//! \return Pointer to the Vortex field
template <typename T>
VxData::FieldBase* DtVortexInterfaceElement<T>::getField() const
{
   return myVortexField;
}
 
//! \brief Sets the Vortex field
//!
//! \param field Pointer to the Vortex field
template <typename T>
void DtVortexInterfaceElement<T>::setField(VxData::FieldBase* field)
{
   myVortexField = field;
}
 
//---------------------------------------------------------------------------------------------------------------------
 
//! \brief Class for managing Vortex interfaces
//!
//! Provides functionality for creating and managing the connection between VR-Forces ports
//! and Vortex interfaces. Handles both input and output ports.
class VREVRFVORTEX_DLL DtVortexInterface
{
public:
   //! \brief Constructor
   //!
   //! Creates ports based on the descriptor and optionally connects them to the Vortex interface.
   //!
   //! \param desc Descriptor containing interface configuration
   //! \param iface Optional Vortex interface to connect to
   DtVortexInterface(
      makVre::DtVortexInterfaceDescriptor* desc, const VxSim::VxWeakInterface<VxSim::VxVHLInterface>& iface = nullptr);
 
   //! \brief Destructor
   //!
   //! Cleans up resources.
   virtual ~DtVortexInterface();
 
   //! \brief Gets the input port group
   //!
   //! Provides access to all input ports.
   //!
   //! \return Pointer to the input port group
   virtual DtInputPortGroup* inputPortGroup();
 
   //! \brief Gets the output port group
   //!
   //! Provides access to all output ports.
   //!
   //! \return Pointer to the output port group
   virtual DtOutputPortGroup* outputPortGroup();
 
   //! \brief Updates all input elements
   //!
   //! Transfers data from input ports to Vortex fields.
   virtual void updateInputs();
 
   //! \brief Updates all output elements
   //!
   //! Transfers data from Vortex fields to output ports.
   virtual void updateOutputs();
 
   //! \brief Updates the object state repository with output values
   //!
   //! Transfers data from output ports to the state repository.
   //!
   //! \param esr Pointer to the object state repository
   virtual void updateOutputStateRepository(DtVrfObjectStateRepository* esr);
 
   //! \brief Sets the Vortex interface
   //!
   //! \param iface Vortex interface to connect to
   virtual void setInterface(VxSim::VxWeakInterface<VxSim::VxVHLInterface> iface);
 
   //! \brief Connects ports to the Vortex interface
   //!
   //! Associates each port with the corresponding Vortex field.
   virtual void connectPortsToInterface();
 
   //! \brief Gets an input element by name
   //!
   //! \param name Name of the input element
   //! \return Pointer to the input element, or nullptr if not found
   virtual DtVortexInterfaceBaseElement* getInputElement(const std::string& name);
 
   //! \brief Gets an output element by name
   //!
   //! \param name Name of the output element
   //! \return Pointer to the output element, or nullptr if not found
   virtual DtVortexInterfaceBaseElement* getOutputElement(const std::string& name);
 
   //! \brief Gets the interface name
   //!
   //! \return The name of the interface
   virtual std::string getInterfaceName();
 
protected:
   //! \brief Creates ports based on the descriptor
   //!
   //! Creates input and output ports of appropriate types according to the descriptor.
   //!
   //! \param desc Descriptor containing interface configuration
   virtual void createPorts(makVre::DtVortexInterfaceDescriptor* desc);
 
   VxSim::VxWeakInterface<VxSim::VxVHLInterface> myInterface;   //!< Vortex interface
   std::string myInterfaceName;                                 //!< Interface name
   DtInputPortGroup* myInputPortGroup;                          //!< Input port group
   DtOutputPortGroup* myOutputPortGroup;                        //!< Output port group
   std::vector<DtVortexInterfaceBaseElement*> myInputElements;  //!< Vector of input elements
   std::vector<DtVortexInterfaceBaseElement*> myOutputElements; //!< Vector of output elements
};