Material.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 <agx/agxPhysics_export.h>
#include <agxStream/Serializable.h>
#include <agx/FrictionModel.h>
#include <agx/Physics/MaterialEntity.h>
#include <agx/Physics/BulkMaterialEntity.h>
#include <agx/Physics/SurfaceMaterialEntity.h>
#include <agx/Physics/WireMaterialEntity.h>
#include <agx/Physics/ContactMaterialEntity.h>
#include <agx/macros.h>
#include <agx/SetVector.h>
 
 
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4251) // warning C4251: class X needs to have dll-interface to be used by clients of class Y
#endif
 
namespace agxSDK
{
  class MaterialManager;
}
namespace agxIO
{
  class SceneExporter;
}
namespace agxCollide
{
  class GeometryContact;
}
namespace agxData
{
  class EntityStorage;
}
 
namespace agx
{
  AGX_DECLARE_POINTER_TYPES(BulkMaterial);
  AGX_DECLARE_POINTER_TYPES(SurfaceMaterial);
  AGX_DECLARE_POINTER_TYPES(WireMaterial);
  AGX_DECLARE_POINTER_TYPES(Material);
  AGX_DECLARE_POINTER_TYPES(ContactMaterial);
  typedef agx::SetVector< agx::ref_ptr<agx::ContactMaterial> > ContactMaterialRefSetVector;
  typedef agx::Vector<agx::ref_ptr<agx::ContactMaterial> > ContactMaterialRefVector;
 
 
  class AGXPHYSICS_EXPORT BulkMaterial : public Referenced, public virtual agxStream::Serializable
  {
    public:
 
      BulkMaterial();
 
      void setDensity(Real density);
 
      Real getDensity() const;
 
      void setYoungsModulus(Real value);
 
      Real getYoungsModulus() const;
 
      Real getDamping() const;
 
      void setDamping( Real damping );
 
      bool setMinMaxElasticRestLength(Real minElasticRestLength, Real maxElasticRestLength);
 
      Real getMinElasticRestLength() const;
 
      Real getMaxElasticRestLength() const;
 
      void copy( const BulkMaterial* source );
 
      void setViscosity( Real viscosity );
 
      Real getViscosity() const;
 
      bool isDirty() const;
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agx::BulkMaterial );
 
      Physics::BulkMaterialPtr& getEntity();
 
      const Physics::BulkMaterialPtr& getEntity() const;
 
    protected:
 
      friend class Material;
 
      AGX_FORCE_INLINE void setDirty( bool flag ) const;
      DOXYGEN_END_INTERNAL_BLOCK()
 
      virtual ~BulkMaterial();
 
 
 
    private:
      mutable Physics::BulkMaterialRef m_entity;
  };
 
 
  class AGXPHYSICS_EXPORT SurfaceMaterial :  public Referenced, public virtual agxStream::Serializable
  {
    public:
 
      SurfaceMaterial();
 
      void setRoughness( Real roughness );
 
      Real getRoughness() const;
 
      void setAdhesion( Real adhesion, Real adhesiveOverlap );
 
      Real getAdhesion() const;
 
      Real getAdhesiveOverlap() const;
 
      void setViscosity( Real viscosity );
 
      Real getViscosity() const;
 
      bool getFrictionEnabled() const;
 
      void setFrictionEnabled( bool flag );
 
      bool isDirty() const;
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agx::SurfaceMaterial );
 
 
      void copy( const SurfaceMaterial* source );
 
      Physics::SurfaceMaterialPtr& getEntity();
 
      const Physics::SurfaceMaterialPtr& getEntity() const;
 
    protected:
 
      friend class Material;
      void setDirty( bool flag ) const;
 
      DOXYGEN_END_INTERNAL_BLOCK()
 
      virtual ~SurfaceMaterial();
 
    private:
      mutable Physics::SurfaceMaterialRef m_entity;
  };
 
 
  class AGXPHYSICS_EXPORT WireMaterial :  public Referenced, public virtual agxStream::Serializable
  {
    public:
 
      WireMaterial();
 
      Real getYoungsModulusStretch() const;
 
      Real getDampingStretch() const;
 
      Real getYoungsModulusBend() const;
 
      Real getDampingBend() const;
 
      void setYoungsModulusStretch( Real youngsStretch );
 
      void setDampingStretch( Real dampingStretch );
 
      void setYoungsModulusBend( Real youngsBend );
 
      void setDampingBend( Real dampingBend );
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agx::WireMaterial );
 
      bool isDirty() const;
      void setDirty(bool flag) const;
 
      void copy( const WireMaterial* source );
 
      Physics::WireMaterialPtr& getEntity();
 
      const Physics::WireMaterialPtr& getEntity() const;
 
    protected:
 
      friend class Material;
      DOXYGEN_END_INTERNAL_BLOCK()
 
      virtual ~WireMaterial();
 
    private:
      mutable Physics::WireMaterialRef m_entity;
  };
 
 
 
  class AGXPHYSICS_EXPORT Material :  public Referenced, public virtual agxStream::Serializable
  {
    public:
 
      Material( const agx::Name& name, const Material* parent = nullptr );
 
      Material( const agx::Name& name, Real restitution, Real friction );
 
      Material( const Material& material );
 
      SurfaceMaterial* getSurfaceMaterial();
 
      const SurfaceMaterial* getSurfaceMaterial() const;
 
      BulkMaterial* getBulkMaterial();
 
      const BulkMaterial* getBulkMaterial() const;
 
      WireMaterial* getWireMaterial();
 
      const WireMaterial* getWireMaterial() const;
 
      const agx::Name& getName() const;
 
      void setName( const agx::Name& name ) {
        m_entity.name() = name;
      }
 
      static Material* getDefaultMaterial();
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
      
      bool isDirty() const;
 
 
      bool loadLibraryMaterial( agx::String name );
 
 
      static agx::StringVector getAvailableLibraryMaterials();
 
 
      bool isLibraryMaterial() const;
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agx::Material );
 
 
      Physics::MaterialPtr& getEntity();
 
      const Physics::MaterialPtr& getEntity() const;
 
      void copy(const Material* other);
 
      DOXYGEN_END_INTERNAL_BLOCK()
 
 
    protected:
 
      Material();
 
      virtual ~Material();
 
    private:
      friend class agxSDK::MaterialManager;
      void setDirty( bool flag ) const;
 
      void init(const Name& name);
 
    private:
      BulkMaterialRef m_bulkMaterial;
      SurfaceMaterialRef m_surfaceMaterial;
      WireMaterialRef m_wireMaterial;
 
      mutable Physics::MaterialRef m_entity;
  };
 
 
  class AGXPHYSICS_EXPORT ContactMaterial : public Referenced, public virtual agxStream::Serializable
  {
    public:
      enum FrictionDirection {
        PRIMARY_DIRECTION,
        SECONDARY_DIRECTION,
        BOTH_PRIMARY_AND_SECONDARY
      };
 
      enum ContactReductionMode {
        REDUCE_NONE,               
        REDUCE_GEOMETRY,           
        REDUCE_ALL                 
      };
 
    public:
 
      ContactMaterial( const Material* m1, const Material* m2, bool implicit=false );
 
      ContactMaterial( const ContactMaterial* other, bool implicit );
 
      void setRestitution( Real restitution );
 
      void setTangentialRestitution( Real restitution, FrictionDirection direction = BOTH_PRIMARY_AND_SECONDARY );
 
      void setTangentialCohesion( Real cohesion, FrictionDirection direction = BOTH_PRIMARY_AND_SECONDARY );
 
      void setFrictionCoefficient( Real friction, FrictionDirection direction = BOTH_PRIMARY_AND_SECONDARY );
 
      void setSurfaceViscosity( Real viscosity, FrictionDirection direction = BOTH_PRIMARY_AND_SECONDARY );
 
      void setAdhesion( Real adhesion, Real adhesiveOverlap );
 
      Real getAdhesion() const;
 
      Real getAdhesiveOverlap() const;
 
      Real getRestitution() const;
 
      Real getTangentialRestitution( FrictionDirection direction = PRIMARY_DIRECTION ) const;
 
      Real getFrictionCoefficient( FrictionDirection direction = PRIMARY_DIRECTION ) const;
 
      Real getTangentialCohesion( FrictionDirection direction = PRIMARY_DIRECTION ) const;
 
      Real getSurfaceViscosity( FrictionDirection direction = PRIMARY_DIRECTION ) const;
 
      bool getSurfaceFrictionEnabled() const;
 
      void setEnableSurfaceFriction( bool flag );
 
      void setYoungsModulus( Real youngsModulus );
 
      Real getYoungsModulus() const ;
 
      void setDamping( Real damping );
 
      bool setMinMaxElasticRestLength(Real minElasticRestLength, Real maxElasticRestLength);
 
      Real getMinElasticRestLength() const;
 
      Real getMaxElasticRestLength() const;
 
      Real getDamping() const ;
 
      FrictionModel* getFrictionModel() const;
 
      void setFrictionModel( FrictionModel* frictionModel );
 
      const Material* getMaterial1() const;
 
      const Material* getMaterial2() const;
 
      bool isExplicit() const;
 
      void setContactReductionMode( ContactReductionMode mode );
 
      ContactReductionMode getContactReductionMode( ) const;
 
      void setContactReductionBinResolution( agx::UInt8 binResolution );
 
      agx::UInt8 getContactReductionBinResolution() const;
 
      void setUseContactAreaApproach( bool useContactAreaApproach );
 
      bool getUseContactAreaApproach() const;
 
      void setRollingResistanceCoefficient(agx::Real rollingCoefficient);
 
      void setTwistingResistanceCoefficient(agx::Real twistingCoefficient);
 
      agx::Real getRollingResistanceCoefficient() const;
 
      agx::Real getTwistingResistanceCoefficient() const;
 
      void setRollingResistanceCompliance(agx::Real compliance);
 
      void setTwistingResistanceCompliance(agx::Real compliance);
 
      agx::Real getRollingResistanceCompliance() const;
 
      agx::Real getTwistingResistanceCompliance() const;
 
      void setImpactCompliance(agx::Real impactCompliance);
 
      agx::Real getImpactCompliance() const;
 
      void setWireFrictionCoefficient( Real friction, FrictionDirection direction = BOTH_PRIMARY_AND_SECONDARY );
 
      Real getWireFrictionCoefficient( FrictionDirection direction = PRIMARY_DIRECTION ) const;
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
      
      agx::ContactMaterial* clone( const agx::Material* material1, const agx::Material* material2 ) const;
 
 
      void copyInto( ContactMaterial& target ) const;
 
      void transfer( agxData::EntityStorage* storage );
 
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agx::ContactMaterial );
 
      Physics::ContactMaterialPtr& getEntity();
 
      const Physics::ContactMaterialPtr& getEntity() const;
 
      enum class RestitutionCoefficient
      {
        NORMAL,
        TANGENTIAL_PRIMARY,
        TANGENTIAL_SECONDARY
      };
 
      DOXYGEN_END_INTERNAL_BLOCK()
 
    protected:
      ContactMaterial();
      virtual ~ContactMaterial();
 
    private:
 
      ContactMaterial( const ContactMaterial& m );
 
      ContactMaterial& operator = ( const ContactMaterial& );
 
      void setDefaultParameters();
 
      friend class agxSDK::MaterialManager;
      friend class agxCollide::GeometryContact;
      friend class agxIO::SceneExporter;
      void setIsExplicit( bool is_explicit );
 
 
    private:
      ref_ptr<const Material> m_material1;
      ref_ptr<const Material> m_material2;
      FrictionModelRef m_frictionModel;
 
      mutable Physics::ContactMaterialRef m_entity;
  };
 
 
  /* Implementation */
 
 
  // SurfaceMaterial AGX_FORCE_INLINE implementation
  AGX_FORCE_INLINE bool SurfaceMaterial::getFrictionEnabled() const
  {
    return m_entity.frictionEnabled();
  }
 
  AGX_FORCE_INLINE Real SurfaceMaterial::getRoughness() const
  {
    return m_entity.roughness();
  }
 
  AGX_FORCE_INLINE Real SurfaceMaterial::getAdhesion() const
  {
    return m_entity.adhesion();
  }
 
  AGX_FORCE_INLINE Real SurfaceMaterial::getAdhesiveOverlap() const
  {
    return m_entity.adhesiveOverlap();
  }
 
  AGX_FORCE_INLINE Real SurfaceMaterial::getViscosity() const
  {
    return m_entity.viscosity();
  }
 
  DOXYGEN_START_INTERNAL_BLOCK()
  AGX_FORCE_INLINE bool SurfaceMaterial::isDirty() const
  {
    return m_entity.dirty();
  }
 
  AGX_FORCE_INLINE void SurfaceMaterial::setDirty( bool flag ) const
  {
    m_entity.dirty() = flag;
  }
  DOXYGEN_END_INTERNAL_BLOCK()
 
  DOXYGEN_START_INTERNAL_BLOCK()
  AGX_FORCE_INLINE bool WireMaterial::isDirty() const
  {
    return m_entity.dirty();
  }
 
  AGX_FORCE_INLINE void WireMaterial::setDirty( bool flag ) const
  {
    m_entity.dirty() = flag;
  }
  DOXYGEN_END_INTERNAL_BLOCK()
 
  AGX_FORCE_INLINE Real WireMaterial::getYoungsModulusStretch() const
  {
    return m_entity.youngsModulusStretch();
  }
 
  AGX_FORCE_INLINE Real WireMaterial::getDampingStretch() const
  {
    return m_entity.dampingStretch();
  }
 
  AGX_FORCE_INLINE Real WireMaterial::getYoungsModulusBend() const
  {
    return m_entity.youngsModulusBend();
  }
 
  AGX_FORCE_INLINE Real WireMaterial::getDampingBend() const
  {
    return m_entity.dampingBend();
  }
 
  AGX_FORCE_INLINE void WireMaterial::setYoungsModulusStretch( Real youngsStretch )
  {
    setDirty( true );
    m_entity.youngsModulusStretch() = youngsStretch;
  }
 
  AGX_FORCE_INLINE void WireMaterial::setDampingStretch( Real dampingStretch )
  {
    setDirty( true );
    m_entity.dampingStretch() = dampingStretch;
  }
 
  AGX_FORCE_INLINE void WireMaterial::setYoungsModulusBend( Real youngsBend )
  {
    setDirty( true );
    m_entity.youngsModulusBend() = youngsBend;
  }
 
  AGX_FORCE_INLINE void WireMaterial::setDampingBend( Real dampingBend )
  {
    setDirty( true );
    m_entity.dampingBend() = dampingBend;
  }
 
  // BulkMaterial AGX_FORCE_INLINE implementation
  AGX_FORCE_INLINE Real BulkMaterial::getViscosity() const
  {
    return m_entity.viscosity();
  }
 
  AGX_FORCE_INLINE Real BulkMaterial::getDamping() const
  {
    return m_entity.damping();
  }
 
  AGX_FORCE_INLINE Real BulkMaterial::getYoungsModulus() const
  {
    return m_entity.youngsModulus();
  }
 
  AGX_FORCE_INLINE Real BulkMaterial::getDensity() const
  {
    return m_entity.density();
  }
 
  AGX_FORCE_INLINE bool BulkMaterial::isDirty() const
  {
    return m_entity.dirty();
  }
 
  DOXYGEN_START_INTERNAL_BLOCK()
  AGX_FORCE_INLINE void BulkMaterial::setDirty( bool flag ) const
  {
    m_entity.dirty() = flag;
  }
  DOXYGEN_END_INTERNAL_BLOCK()
 
  // Material AGX_FORCE_INLINE implementation
  AGX_FORCE_INLINE SurfaceMaterial* Material::getSurfaceMaterial()
  {
    return m_surfaceMaterial;
  }
 
  AGX_FORCE_INLINE const SurfaceMaterial* Material::getSurfaceMaterial() const
  {
    return m_surfaceMaterial;
  }
 
  AGX_FORCE_INLINE BulkMaterial* Material::getBulkMaterial()
  {
    return m_bulkMaterial;
  }
 
  AGX_FORCE_INLINE const BulkMaterial* Material::getBulkMaterial() const
  {
    return m_bulkMaterial;
  }
 
  AGX_FORCE_INLINE WireMaterial* Material::getWireMaterial()
  {
    return m_wireMaterial;
  }
 
  AGX_FORCE_INLINE const WireMaterial* Material::getWireMaterial() const
  {
    return m_wireMaterial;
  }
 
  DOXYGEN_START_INTERNAL_BLOCK()
  AGX_FORCE_INLINE bool Material::isDirty() const
  {
    return m_surfaceMaterial->isDirty() || m_bulkMaterial->isDirty() || m_wireMaterial->isDirty();
  }
 
  AGX_FORCE_INLINE void Material::setDirty( bool flag ) const
  {
    m_surfaceMaterial->setDirty(flag);
    m_bulkMaterial->setDirty(flag);
    m_wireMaterial->setDirty(flag);
  }
  DOXYGEN_END_INTERNAL_BLOCK()
 
 
  AGX_FORCE_INLINE const agx::Name& Material::getName() const
  {
    return m_entity.name();
  }
 
  // ContactMaterial AGX_FORCE_INLINE implementation
  AGX_FORCE_INLINE Real ContactMaterial::getRestitution() const
  {
    return m_entity.restitution()[ (int)RestitutionCoefficient::NORMAL ];
  }
 
  AGX_FORCE_INLINE Real ContactMaterial::getFrictionCoefficient(FrictionDirection direction) const
  {
    return m_entity.friction()[ agx::clamp< int >( direction, 0, 1 ) ];
  }
 
  AGX_FORCE_INLINE Real ContactMaterial::getSurfaceViscosity( FrictionDirection direction /* = PRIMARY_DIRECTION */ ) const
  {
    return m_entity.viscosity()[ agx::clamp< int >( direction, 0, 1 ) ];
  }
 
  AGX_FORCE_INLINE Real ContactMaterial::getAdhesion() const
  {
    return m_entity.adhesion();
  }
 
  AGX_FORCE_INLINE Real ContactMaterial::getAdhesiveOverlap() const
  {
    return m_entity.adhesiveOverlap();
  }
 
  AGX_FORCE_INLINE bool ContactMaterial::getSurfaceFrictionEnabled() const
  {
    return m_entity.surfaceFrictionEnabled();
  }
 
  AGX_FORCE_INLINE Real ContactMaterial::getYoungsModulus() const
  {
    return m_entity.youngsModulus();
  }
 
  AGX_FORCE_INLINE Real ContactMaterial::getDamping() const
  {
    return m_entity.damping();
  }
 
  AGX_FORCE_INLINE FrictionModel* ContactMaterial::getFrictionModel() const
  {
    return m_frictionModel;
  }
 
  AGX_FORCE_INLINE bool ContactMaterial::isExplicit() const
  {
    return m_entity.isExplicit();
  }
 
  AGX_FORCE_INLINE const Material* ContactMaterial::getMaterial1() const
  {
    return m_material1;
  }
 
  AGX_FORCE_INLINE const Material* ContactMaterial::getMaterial2() const
  {
    return m_material2;
  }
 
  AGX_FORCE_INLINE ContactMaterial::ContactReductionMode ContactMaterial::getContactReductionMode( ) const
  {
    return (ContactReductionMode)m_entity.contactReductionMode();
  }
 
  AGX_FORCE_INLINE agx::UInt8 ContactMaterial::getContactReductionBinResolution() const
  {
    return m_entity.contactReductionBinResolution();
  }
 
  DOXYGEN_START_INTERNAL_BLOCK()
 
  AGX_FORCE_INLINE Physics::BulkMaterialPtr& BulkMaterial::getEntity()
  {
    return m_entity;
  }
  AGX_FORCE_INLINE const Physics::BulkMaterialPtr& BulkMaterial::getEntity() const
  {
    return m_entity;
  }
 
  AGX_FORCE_INLINE Physics::SurfaceMaterialPtr& SurfaceMaterial::getEntity()
  {
    return m_entity;
  }
 
  AGX_FORCE_INLINE const Physics::SurfaceMaterialPtr& SurfaceMaterial::getEntity() const
  {
    return m_entity;
  }
 
 
  AGX_FORCE_INLINE Physics::WireMaterialPtr& WireMaterial::getEntity()
  {
    return m_entity;
  }
 
  AGX_FORCE_INLINE const Physics::WireMaterialPtr& WireMaterial::getEntity() const
  {
    return m_entity;
  }
 
 
  AGX_FORCE_INLINE Physics::MaterialPtr& Material::getEntity()
  {
    return m_entity;
  }
 
  AGX_FORCE_INLINE const Physics::MaterialPtr& Material::getEntity() const
  {
    return m_entity;
  }
 
 
  AGX_FORCE_INLINE Physics::ContactMaterialPtr& ContactMaterial::getEntity()
  {
    return m_entity;
  }
 
  AGX_FORCE_INLINE const Physics::ContactMaterialPtr& ContactMaterial::getEntity() const
  {
    return m_entity;
  }
  DOXYGEN_END_INTERNAL_BLOCK()
 
  AGX_FORCE_INLINE agx::Real ContactMaterial::getRollingResistanceCoefficient() const
  {
    return m_entity.rollingResistanceCoefficient();
  }
 
  AGX_FORCE_INLINE agx::Real ContactMaterial::getRollingResistanceCompliance() const
  {
    return m_entity.rollingResistanceCompliance();
  }
 
  AGX_FORCE_INLINE agx::Real ContactMaterial::getTwistingResistanceCompliance() const
  {
    return m_entity.twistingResistanceCompliance();
  }
 
  AGX_FORCE_INLINE agx::Real agx::ContactMaterial::getImpactCompliance() const
  {
    return m_entity.impactCompliance();
  }
 
  AGX_FORCE_INLINE bool agx::ContactMaterial::getUseContactAreaApproach() const
  {
    return m_entity.useContactAreaApproach();
  }
 
  AGX_FORCE_INLINE Real ContactMaterial::getWireFrictionCoefficient(FrictionDirection direction) const
  {
    return m_entity.wireFriction()[ agx::clamp< int >( direction, 0, 1 ) ];
  }
} // namespace agx
 
#ifdef _MSC_VER
#  pragma warning(pop)
#endif