vortexPart.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2024 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file    vortexPart.h
//! \brief   Classes for representing parts in the Vortex physics simulation
//! \ingroup vreVrfVortex
 
#pragma once
 
#include <vreVrfVortex/export.h>
 
#include <matrix/vlVector.h>
#include <matrix/vlTaitBryan.h>
 
#include <Vx/VxTransform.h>
#include <Vx/VxSmartPtr.h>
 
#include <VxSim/VxSmartInterface.h>
 
namespace makVre
{
class DtVortexSimArtPartDescriptor;
}
 
class DtArticulatedPart;
class DtUpdateRepositoryOutputPortGroup;
 
//! \brief Wheel articulated part IDs used in the system
//! \details
//! 7840 Wheel 1  left front
//! 7872 Wheel 2  right front
//! 7904 Wheel 3  left etc...
//! 7936 Wheel 4  right etc...
//! 7968 Wheel 5
//! 8000 Wheel 6
//! 8032 Wheel 7
//! 8064 Wheel 8
//! 8096 Wheel 9
//! 8128 Wheel 10
//! 8160 Wheel 11
//! 8192 Wheel 12
//! 8224 Wheel 13
//! 8256 Wheel 14
//! 8288 Wheel 15
//! 8320 Wheel 16
//! 8352 Wheel 17
//! 8384 Wheel 18
//! 8416 Wheel 19
//! 8448 Wheel 20
 
namespace Vx
{
class VxPart;
}
 
namespace VxData
{
class FieldBase;
}
 
namespace VxSim
{
class VxExtension;
class VxPluginExtension;
class VxVHLInterface;
class VxSimulationState;
} // namespace VxSim
 
namespace VxDynamics
{
class Part;
}
 
//! \brief Base class for Vortex parts in the physics simulation
//!
//! Provides common functionality for different types of parts including position,
//! orientation, and motion tracking. Derived classes implement specific behaviors
//! for different part types such as wheels and turrets.
class VREVRFVORTEX_DLL DtVortexBasePart
{
public:
   //! \brief Enumeration defining possible part motion types
   //!
   //! These flags can be combined to define which degrees of freedom
   //! a part supports.
   enum DtPartMotion
   {
      X = 0x01,                                    //!< Motion along X axis
      Y = 0x02,                                    //!< Motion along Y axis
      Z = 0x04,                                    //!< Motion along Z axis
      TRANSLATION = X | Y | Z,                     //!< All translational motion
      AZIMUTH = 0x10,                              //!< Rotation around Z axis
      ELEVATION = 0x20,                            //!< Rotation around Y axis
      ROTATION = 0x40,                             //!< Rotation around X axis
      ORIENTATION = AZIMUTH | ELEVATION | ROTATION //!< All rotational motion
   };
 
public:
   //! \brief Constructor
   //!
   //! Creates a part with the specified descriptor and parent.
   //!
   //! \param desc The part descriptor containing configuration
   //! \param parent The parent part, or nullptr for root parts
   DtVortexBasePart(makVre::DtVortexSimArtPartDescriptor* desc, DtVortexBasePart* parent);
 
   //! \brief Virtual destructor
   virtual ~DtVortexBasePart();
 
   //! \brief Gets the parameter IDs associated with this part
   //!
   //! \return Vector of parameter IDs
   virtual const std::vector<int>& paramIds() const { return myParamterIds; }
 
   //! \brief Initializes the part
   //!
   //! Sets up the part and its connections to the physics engine.
   //!
   //! \return True if initialization succeeded, false otherwise
   virtual bool init() = 0;
 
   //! \brief Updates the part state
   //!
   //! Called every frame by the movement actuator. Takes data from Vortex
   //! and produces values translated for publishing.
   virtual void update() = 0;
 
   //! \brief Gets the local transform in Vortex coordinates
   //!
   //! \return Local transform in NWU coordinates
   virtual Vx::VxTransform transform() const = 0;
 
   //! \brief Gets the world transform in Vortex coordinates
   //!
   //! \return World transform in NWU coordinates
   virtual Vx::VxTransform worldTransform() const = 0;
 
   //! \brief Resets the initial part positions
   //!
   //! Derived classes may implement this to reset specific part positions.
   virtual void resetInitialPartPositions() {}
 
   //! \brief Resets the part to its initial state in Vortex
   virtual void reset();
 
   //! \brief Gets the parent part
   //!
   //! \return Reference to the parent part
   virtual DtVortexBasePart& parent() const;
 
   //! \brief Checks if this part has the specified motion capability
   //!
   //! \param motion The motion type to check (from DtPartMotion enum)
   //! \return True if this part is configured with the specified motion
   virtual bool hasMotion(DtPartMotion motion) const;
 
   //! \brief Gets the part ID
   //!
   //! Gets this part's articulated part ID (see disEnums.h).
   //!
   //! \return The part ID
   virtual inline int partId() const { return myPartId; }
 
   //! \brief Gets the parent part ID
   //!
   //! \return The parent part ID
   virtual inline int parentId() const { return myParentId; }
 
   //! \brief Gets the position in NED coordinate system
   //!
   //! Returns the position in the articulated part standard coordinate system.
   //!
   //! \return Current part position
   virtual inline DtVector position() const { return myPosition; }
 
   //! \brief Gets the current velocity
   //!
   //! \return Current velocity vector
   virtual inline DtVector velocity() const { return myVelocity; }
 
   //! \brief Gets the current acceleration
   //!
   //! \return Current acceleration vector
   virtual inline DtVector acceleration() const { return myAcceleration; }
 
   //! \brief Gets the current orientation
   //!
   //! \return Current orientation as Tait-Bryan angles
   virtual inline DtTaitBryan orientation() const { return myOrientation; }
 
   //! \brief Gets the current angular velocity
   //!
   //! \return Current angular velocity vector
   virtual inline DtVector angularVelocity() const { return myAngularVelocity; }
 
   //! \brief Gets the part name
   //!
   //! Returns the name of this part as defined in the descriptor.
   //!
   //! \return Part name
   virtual inline const std::string& name() const { return myName; }
 
protected:
   std::string myName;                                 //!< Part name
   DtVortexBasePart* myParent;                         //!< Parent part
   makVre::DtVortexSimArtPartDescriptor* myDescriptor; //!< Part descriptor
 
   int myParentId;                                     //!< Parent part ID
   int myPartId;                                       //!< This part's ID
 
   int myMotion;                                       //!< Supported motion types (bitmask)
 
   std::vector<int> myParamterIds;                     //!< Parameter IDs for this part
 
   DtVector myPosition;                                //!< Current position
   DtVector myVelocity;                                //!< Current velocity
   DtVector myAcceleration;                            //!< Current acceleration
 
   DtTaitBryan myOrientation;                          //!< Current orientation
   DtVector myAngularVelocity;                         //!< Current angular velocity
};
 
//---------------------------------------------------------------------------------------------------------------------
 
//! \brief Standard Vortex part implementation
//!
//! Used primarily for the chassis, turret, and main gun parts.
//! Wraps a Vortex physics part and provides access to its properties.
class VREVRFVORTEX_DLL DtVortexPart : public DtVortexBasePart
{
public:
   //! \brief Constructor
   //!
   //! \param part Pointer to the Vortex part
   //! \param desc Part descriptor
   //! \param parent Pointer to the parent part
   DtVortexPart(Vx::VxPart* part, makVre::DtVortexSimArtPartDescriptor* desc, DtVortexBasePart* parent);
 
   //! \brief Destructor
   virtual ~DtVortexPart() override;
 
   //! \brief Initializes the part
   //!
   //! \return True if initialization succeeded, false otherwise
   virtual bool init() override;
 
   //! \brief Updates the part state from Vortex
   virtual void update() override;
 
   //! \brief Gets the local transform
   //!
   //! \return Local transform in Vortex coordinates
   virtual Vx::VxTransform transform() const override;
 
   //! \brief Gets the world transform
   //!
   //! \return World transform in Vortex coordinates
   virtual Vx::VxTransform worldTransform() const override;
 
   //! \brief Resets the initial part positions
   virtual void resetInitialPartPositions() override;
 
   //! \brief Resets the part to its initial state
   virtual void reset() override;
 
   //! \brief Gets the underlying Vortex part
   //!
   //! \return Pointer to the Vortex part
   virtual Vx::VxPart* getPart();
 
protected:
   //! \brief Calculates the current position
   //!
   //! \return Current position vector
   DtVector calculatePosition();
 
   //! \brief Calculates the current orientation
   //!
   //! \return Current orientation as Tait-Bryan angles
   DtTaitBryan calculateOrientation();
 
   //! \brief Calculates the current linear velocity
   //!
   //! \return Current velocity vector
   DtVector calculateLinearVelocity();
 
   //! \brief Calculates the current angular velocity
   //!
   //! \return Current angular velocity vector
   DtVector calculateAngularVelocity();
 
   //! \brief Calculates the current acceleration
   //!
   //! \return Current acceleration vector
   DtVector calculateAccleration();
 
   Vx::VxPart* myPart; //!< The Vortex physics part
};
 
//---------------------------------------------------------------------------------------------------------------------
 
//! \brief Dynamics-based Vortex part implementation
//!
//! Used for parts that rely on the Vortex dynamics extension,
//! such as wheels and tracks.
class VREVRFVORTEX_DLL DtVortexDynamicsPart : public DtVortexBasePart
{
public:
   //! \brief Constructor
   //!
   //! \param dynamicsExt The Vortex dynamics extension
   //! \param desc Part descriptor
   //! \param parent Pointer to the parent part
   DtVortexDynamicsPart(Vx::VxWeakPtr<VxSim::VxExtension> dynamicsExt, makVre::DtVortexSimArtPartDescriptor* desc,
      DtVortexBasePart* parent);
 
   //! \brief Destructor
   virtual ~DtVortexDynamicsPart() override;
 
   //! \brief Initializes the part
   //!
   //! \return True if initialization succeeded, false otherwise
   virtual bool init() override;
 
   //! \brief Updates the part state from Vortex
   virtual void update() override;
 
   //! \brief Gets the local transform
   //!
   //! \return Local transform in Vortex coordinates
   virtual Vx::VxTransform transform() const override;
 
   //! \brief Gets the world transform
   //!
   //! \return World transform in Vortex coordinates
   virtual Vx::VxTransform worldTransform() const override;
 
   //! \brief Gets the wheel radius
   //!
   //! \return Wheel radius in meters
   double wheelRadius();
 
   //! \brief Resets the initial part positions
   virtual void resetInitialPartPositions() override;
 
   //! \brief Resets the part to its initial state
   //!
   //! See DtVortexBasePart::reset()
   virtual void reset() override;
 
protected:
   //! \brief Initializes a car wheel
   //!
   //! \return True if initialization succeeded, false otherwise
   virtual bool initializeCarWheel();
 
   //! \brief Initializes a track sprocket
   //!
   //! \return True if initialization succeeded, false otherwise
   virtual bool initializeTrackSprocket();
 
   //! \brief Initializes a track idler
   //!
   //! \return True if initialization succeeded, false otherwise
   virtual bool initializeTrackIdler();
 
   //! \brief Initializes a track wheel
   //!
   //! \return True if initialization succeeded, false otherwise
   virtual bool initializeTrackWheel();
 
   double myDynamicWheelRadius;                     //!< Wheel radius for dynamics calculations
   Vx::VxTransform myDOFTransform;                  //!< Degree of freedom transform
   Vx::VxWeakPtr<VxSim::VxExtension> myDynamicsExt; //!< The dynamics extension
   VxData::FieldBase* myDynamicsTransform;          //!< The dynamics transform field
   VxData::FieldBase* myDynamicsContactMaterial;    //!< The dynamics contact material field
};
 
//---------------------------------------------------------------------------------------------------------------------
 
//! \brief Modular vehicle part implementation
//!
//! Used for parts in modular vehicles where parts connect to a base chassis.
class VREVRFVORTEX_DLL DtVortexModularPart : public DtVortexBasePart
{
public:
   //! \brief Constructor
   //!
   //! \param part The Vortex dynamics part interface
   //! \param desc Part descriptor
   //! \param parent Pointer to the parent part
   DtVortexModularPart(VxSim::VxWeakInterface<VxDynamics::Part> part, makVre::DtVortexSimArtPartDescriptor* desc,
      DtVortexBasePart* parent);
 
   //! \brief Destructor
   virtual ~DtVortexModularPart() override;
 
   //! \brief Initializes the part
   //!
   //! \return True if initialization succeeded, false otherwise
   virtual bool init() override;
 
   //! \brief Updates the part state from Vortex
   virtual void update() override;
 
   //! \brief Resets the part to its initial state
   virtual void reset() override;
 
   //! \brief Checks if the parent transform is valid
   //!
   //! Needed because modular vehicles do not update their parts until the simulation starts.
   //!
   //! \return True if the parent transform is valid, false otherwise
   virtual bool isParentTransformValid();
 
   //! \brief Updates the parent transform
   virtual void updateParentTransform();
 
   //! \brief Gets the local transform
   //!
   //! \return Local transform in Vortex coordinates
   virtual Vx::VxTransform transform() const override;
 
   //! \brief Gets the world transform
   //!
   //! \return World transform in Vortex coordinates
   virtual Vx::VxTransform worldTransform() const override;
 
protected:
   VxSim::VxWeakInterface<VxDynamics::Part> myPart; //!< The Vortex dynamics part
   Vx::VxTransform myTransformToChassis;            //!< Transform from part to chassis
};