DeformableObject.h

Go to the documentation of this file.

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
 
#pragma once
 
#include <agxModel/DeformableObjectReferenceData.h>
#include <agxModel/DeformableTetrahedronMesh.h>
#include <agxModel/DeformableAlgorithm.h>
 
#include <agxModel/BeamModelProperties.h>
 
#include <agxSDK/DeformableObjectInstance.h>
 
#include <agxCollide/HeightField.h>
 
namespace agxModel
{
  AGX_DECLARE_POINTER_TYPES( DeformableObject );
  AGX_DECLARE_VECTOR_TYPES( DeformableObject );
 
  class AGXMODEL_EXPORT DeformableObject : public agxSDK::DeformableObjectInstance
  {
    public:
      using SingleTetrahedronPositions = std::array<agx::Vec3, 4u>;
 
    public:
      static constexpr agx::Real DefaultVertexMergeDistance = DTetrahedronMesh::DefaultVertexMergeDistance;
 
    public:
      struct TetrahedronType {};
 
      struct BoxType {};
 
      struct SphereType {};
 
      struct CylinderType {};
 
      struct CapsuleType {};
 
      struct ConeType {};
 
      struct TetGenType {};
 
      struct RectangularBeamType {};
 
      struct SurfaceType {};
 
      struct ConvexMeshType {};
 
      static constexpr TetrahedronType Tetrahedron{};
      
      static constexpr BoxType Box{};
      
      static constexpr SphereType Sphere{};
      
      static constexpr CylinderType Cylinder{};
 
      static constexpr CapsuleType Capsule{};
 
      static constexpr ConeType Cone{};
 
      static constexpr TetGenType TetGen{};
 
      static constexpr RectangularBeamType RectangularBeam{};
 
      static constexpr SurfaceType Surface{};
 
      static constexpr ConvexMeshType ConvexMesh{};
 
    public:
      static DeformableObjectRef create( TetrahedronType tag,
                                         SingleTetrahedronPositions positions,
                                         BeamModelProperties* properties = nullptr,
                                         agx::Real vertexMergeDistance = DefaultVertexMergeDistance );
 
      static DeformableObjectRef create( SphereType tag,
                                         agx::Real radius,
                                         agx::Real resolution,
                                         BeamModelProperties* properties = nullptr,
                                         agx::Real vertexMergeDistance = DefaultVertexMergeDistance );
 
      static DeformableObjectRef create( BoxType tag,
                                         agx::Vec3 halfExtents,
                                         BeamModelProperties* properties = nullptr,
                                         agx::Real vertexMergeDistance = DefaultVertexMergeDistance );
 
      static DeformableObjectRef create( CylinderType tag,
                                         agx::Real radius,
                                         agx::Real length,
                                         agx::Real resolution,
                                         BeamModelProperties* properties = nullptr,
                                         agx::Real vertexMergeDistance = DefaultVertexMergeDistance );
 
      static DeformableObjectRef create( CapsuleType tag,
                                         agx::Real radius,
                                         agx::Real length,
                                         agx::Real resolution,
                                         BeamModelProperties* properties = nullptr,
                                         agx::Real vertexMergeDistance = DefaultVertexMergeDistance );
 
      static DeformableObjectRef create( ConeType tag,
                                         agx::Real topRadius,
                                         agx::Real bottomRadius,
                                         agx::Real height,
                                         agx::Real resolution,
                                         BeamModelProperties* properties = nullptr,
                                         agx::Real vertexMergeDistance = DefaultVertexMergeDistance );
 
      static DeformableObjectRef create( TetGenType tag,
                                         agx::String filename,
                                         agx::Vec3 scale = agx::Vec3( 1.0, 1.0, 1.0 ),
                                         BeamModelProperties* properties = nullptr,
                                         agx::Real vertexMergeDistance = DefaultVertexMergeDistance );
 
      static DeformableObjectRef create( RectangularBeamType tag,
                                         agx::Vec3 startPosition,
                                         agx::Vec3 endPosition,
                                         agx::Real width,
                                         agx::Real height,
                                         size_t numSegments,
                                         BeamModelProperties* properties = nullptr,
                                         agx::Vec3 worldUpAxis = agx::Vec3::Z_AXIS() );
 
      static DeformableObjectRef create( SurfaceType tag,
                                         const agxCollide::HeightField* heightfield,
                                         agx::Real baseThickness,
                                         BeamModelProperties* properties = nullptr,
                                         agx::Real vertexMergeDistance = DefaultVertexMergeDistance );
 
      static DeformableObjectRef create( ConvexMeshType tag,
                                         agx::String filename,
                                         agx::Vec3 scale = agx::Vec3( 1.0, 1.0, 1.0 ),
                                         BeamModelProperties* properties = nullptr,
                                         agx::Real vertexMergeDistance = DefaultVertexMergeDistance );
 
      static DeformableObjectRef create( ConvexMeshType tag,
                                         agxCollide::Mesh* mesh,
                                         BeamModelProperties* properties = nullptr,
                                         agx::Real vertexMergeDistance = DefaultVertexMergeDistance );
 
      static DeformableObjectRef create( ConvexMeshType tag,
                                         const agx::Vec3Vector& convexVertices,
                                         const agx::UInt32Vector& convexTriangles,
                                         BeamModelProperties* properties = nullptr,
                                         agx::Real vertexMergeDistance = DefaultVertexMergeDistance );
 
      static DeformableObject* get( agxCollide::Geometry* geometry );
 
      static const DeformableObject* get( const agxCollide::Geometry* geometry );
 
      static DeformableObject* get( agx::RigidBody* rb );
 
      static const DeformableObject* get( const agx::RigidBody* rb );
 
      static DeformableObject* find( const agxSDK::Simulation* simulation, const agx::Name& name );
 
      static DeformableObject* find( const agxSDK::Simulation* simulation, const agx::Uuid& uuid );
 
      static agxModel::DeformableObjectPtrVector findAll( const agxSDK::Simulation* simulation );
 
      static agxModel::DeformableObjectPtrVector findAll( const agxSDK::Simulation* simulation, const agx::Name& name );
 
    public:
      DeformableObject( BeamModelProperties* properties = nullptr,
                        agx::Real vertexMergeDistance = DefaultVertexMergeDistance );
 
      DTetrahedronMesh& getMesh();
 
      const DTetrahedronMesh& getMesh() const;
 
      bool isInitialized() const;
 
      agx::Real getRestVolume() const;
 
      agx::Real getCurrentVolume() const;
 
      void setRigidVelocity( const agx::Vec3& linearVelocity, const agx::Vec3& angularVelocity );
 
      agx::Vec3 getCmPosition() const;
 
      agx::Real getMass() const;
 
      bool add( IDeformableAlgorithm* algorithm );
 
      bool remove( IDeformableAlgorithm* algorithm );
 
      IDeformableAlgorithm* getAlgorithm( const agx::Name& name ) const;
 
      template<typename T>
      T* getAlgorithm() const;
 
      BeamModelProperties* getProperties() const;
 
      DVertexElement findClosestSurfaceVertex( const agx::Vec3& worldPoint, bool viaEdge = false ) const;
 
      DVertexElement findClosestVertex( const agx::Vec3& worldPoint, bool viaEdge = false ) const;
 
      DeformableObjectReferenceDataRef getReferenceData() const;
 
    public:
      virtual bool initialize();
 
      virtual agx::Material* getMaterial() const;
 
      virtual void setMaterial( agx::Material* material );
 
      virtual agx::UInt32 getUniqueId() const;
 
      virtual agx::UInt32 getDisabledCollisionGroupId() const;
 
      virtual void setEnableCollisions( agx::RigidBody* rb, bool enable );
 
      virtual bool getEnableCollisions( const agx::RigidBody* rb ) const;
 
      virtual void setEnableCollisions( agxCollide::Geometry* geometry, bool enable );
 
      virtual bool getEnableCollisions( const agxCollide::Geometry* geometry ) const;
 
      virtual void addGroup( agx::UInt32 id );
 
      virtual void removeGroup( agx::UInt32 id );
 
      virtual bool hasGroup( agx::UInt32 id ) const;
 
      virtual void addGroup( const agx::Name& name );
 
      virtual void removeGroup( const agx::Name& name );
 
      virtual bool hasGroup( const agx::Name& name ) const;
 
      virtual agx::Vec2Vector calculateSurfaceTextureCoordinates2D() const;
 
      virtual agx::Vec3Vector calculateSurfaceTextureCoordinates3D() const;
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
    public:
      using agxSDK::Assembly::add;
      using agxSDK::Assembly::remove;
 
      using agxSDK::Assembly::addNotification;
      using agxSDK::Assembly::removeNotification;
 
      virtual void addNotification( agxSDK::Simulation* simulation ) override;
      virtual void removeNotification( agxSDK::Simulation* simulation ) override;
 
      virtual void onPreCollideStep() override;
      virtual void onPreStep() override;
      virtual void onPostStep() override;
      virtual void onLastStep() override;
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agxModel::DeformableObject );
 
    protected:
      using GroupId = IDeformableAlgorithm::GroupId;
      using GroupIdVector = std::vector<GroupId>;
 
    protected:
      virtual void initialize( IDeformableAlgorithm& algorithm );
 
      virtual void onMaterialNew() const;
 
      virtual void onGroupAdd( const GroupId& group ) const;
 
      virtual void onGroupRemove( const GroupId& group ) const;
 
      virtual void onSetEnableCollisions( agxCollide::Geometry* geometry, bool enable ) const;
 
      DOXYGEN_END_INTERNAL_BLOCK()
 
    private:
      struct InternalState
      {
        enum Flag : agx::UInt32
        {
          INITIALIZED = 1 << 0,
        };
        using Flags = agx::BitState<Flag, std::underlying_type_t<Flag>>;
 
        inline bool initialized() const
        {
          return flags.Is( INITIALIZED );
        }
 
        Flags flags;
      };
 
    private:
      friend class agx::InternalData;
      agx::Referenced* getInternalData() const;
 
      void setInternalData( agx::Referenced* data );
 
    private:
      InternalState m_state;
      agx::Uuid m_uniqueId;
      agx::Uuid m_disabledCollisionsId;
      GroupIdVector m_collisionGroups;
      agx::MaterialRef m_material;
      BeamModelPropertiesRef m_properties;
      DeformableObjectReferenceDataRef m_referenceData;
      DTetrahedronMesh m_mesh;
      IDeformableAlgorithmRefVector m_algorithms;
      agx::ref_ptr<agx::Referenced> m_internalData;
  };
 
  template<typename T>
  T* DeformableObject::getAlgorithm() const
  {
    for ( auto&& algorithm : m_algorithms )
      if ( algorithm->template is<T>() )
        return algorithm->template as<T>();
    return nullptr;
  }
 
  inline agx::Referenced* DeformableObject::getInternalData() const
  {
    return m_internalData;
  }
}