agx/Attachment.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/ConstraintAngle.h>
#include <agx/RigidBody.h>
#include <agx/BitState.h>
 
#ifdef _MSC_VER
# pragma warning( push )
# pragma warning( disable : 4251 ) // class X needs to have dll-interface to be used by clients of class Y
# pragma warning(disable: 6385) // Disable warning C6385: Reading invalid data
#endif
 
 
namespace agx
{
  class ConstraintImplementation;
 
  class AGXPHYSICS_EXPORT Attachment : public agx::Referenced, public agxStream::Serializable
  {
    public:
      enum Transformed
      {
        U,                  
        V,                  
        N,                  
        ANCHOR_POS,         
        CM_TO_ANCHOR_POS,   
        NUM_ELEMENTS        
      };
 
    public:
      static void createAttachmentBase( const agx::Vec3d& N, agx::Vec3d& U, agx::Vec3d& V );
      static void createAttachmentBase( const agx::Vec3f& N, agx::Vec3f& U, agx::Vec3f& V );
 
    public:
      Attachment( agx::Frame* relFrame );
 
      virtual void transform();
 
      virtual agx::Bool objectDeleted() const;
 
      virtual agx::Bool valid() const;
 
      const agx::Vec3& get( agx::Attachment::Transformed entry ) const;
 
      agx::Vec3 getLocal( agx::Attachment::Transformed entry ) const;
 
      void setFrame( agx::Frame* frame );
 
      agx::Frame* getFrame() const;
 
      virtual agx::Real calculateDistance( const agx::Attachment* other ) const;
 
      virtual agx::Real calculateLinearDistance( const agx::Attachment* other ) const;
 
      virtual agx::Real calculateLinearSpeed( const agx::Attachment* other ) const;
 
      virtual agx::Real calculateAngularSpeed( const agx::Attachment* other ) const;
 
      virtual agx::Vec3 getLinearVelocity() const;
 
      virtual agx::Vec3 getAngularVelocity() const;
 
      template<typename T>
      agx::Bool is() const;
 
      template<typename T>
      T* as();
 
      template<typename T>
      T* safeAs();
 
      template<typename T>
      const T* as() const;
 
      template<typename T>
      const T* safeAs() const;
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agx::Attachment);
 
    protected:
      Attachment();
 
      virtual ~Attachment();
 
      void transform( const agx::AffineMatrix4x4& cmTransform, const agx::Vec3& cmToModel, const agx::AffineMatrix4x4& localConstraintTransform );
 
    protected:
      agx::Vec3     m_transformed[ NUM_ELEMENTS ];
      agx::FrameRef m_relFrame;
  };
 
  typedef agx::ref_ptr<Attachment> AttachmentRef;
 
  class AGXPHYSICS_EXPORT RigidBodyAttachment : public agx::Attachment
  {
    public:
      RigidBodyAttachment( agx::RigidBody* rb, agx::Frame* relFrame );
 
      virtual agx::Bool objectDeleted() const override;
 
      virtual agx::Bool valid() const override;
 
      virtual agx::Real calculateDistance( const agx::Attachment* other ) const override;
 
      virtual agx::Real calculateLinearDistance( const agx::Attachment* other ) const override;
 
      virtual agx::Real calculateLinearSpeed( const agx::Attachment* other ) const override;
 
      virtual agx::Real calculateAngularSpeed( const agx::Attachment* other ) const override;
 
      virtual agx::Vec3 getLinearVelocity() const override;
 
      virtual agx::Vec3 getAngularVelocity() const override;
 
      virtual void transform() override;
 
      void setRigidBody( agx::RigidBody* rb );
 
      agx::RigidBody* getRigidBody() const;
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agx::RigidBodyAttachment);
 
    protected:
      RigidBodyAttachment();
 
      virtual ~RigidBodyAttachment();
 
    protected:
      agx::RigidBodyObserver m_rb;
      agx::Bool              m_hadValidRb;
  };
 
  typedef agx::ref_ptr<RigidBodyAttachment> RigidBodyAttachmentRef;
 
  class AGXPHYSICS_EXPORT AttachmentPair
  {
    public:
      enum Transformed
      {
        SEPARATION,  
        NUM_ELEMENTS 
      };
 
    public:
      class AGXPHYSICS_EXPORT CustomData : public agx::Referenced
      {
        public:
          virtual void transform( const agx::AttachmentPair& attachmentPair ) = 0;
 
        protected:
          virtual ~CustomData() {}
      };
 
      typedef agx::ref_ptr<CustomData> CustomDataRef;
 
    public:
      AttachmentPair();
 
      virtual ~AttachmentPair();
 
      void set( agx::Attachment* a1, agx::Attachment* a2 );
 
      void add( agx::Angle* angle );
 
      agx::Angle* getAngle( agx::UInt index ) const;
 
      const agx::AngleContainer& getAngles() const;
 
      agx::Bool hasAngle( const agx::Angle* angle ) const;
 
      agx::Real calculateAngularSpeed() const;
 
      agx::Real calculateLinearSpeed() const;
 
      void setCustomData( agx::AttachmentPair::CustomData* customData );
 
      agx::AttachmentPair::CustomData* getCustomData() const;
 
      agx::Attachment* operator[] ( agx::UInt i ) const;
 
      agx::Attachment* getAttachment1() const;
 
      agx::Attachment* getAttachment2() const;
 
      agx::Bool valid() const;
 
      virtual void transform();
 
      virtual void onPostIntegrate( agx::Real dt, const agx::ConstraintImplementation& context );
 
      virtual void onPostSolve( agx::Real dt, const agx::ConstraintImplementation& context );
 
      virtual agx::Bool rebind();
 
      const agx::Vec3& get( agx::AttachmentPair::Transformed entry ) const;
 
      virtual void store( agxStream::OutputArchive& out ) const;
 
      virtual void restore( agxStream::InputArchive& in );
 
      virtual void storeLightData( agxStream::StorageStream& str ) const;
 
      virtual void restoreLightData( agxStream::StorageStream& str );
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
    public:
      void setEnableAttachmentProjections( bool enable, bool projectBody2ToReference = true );
 
      bool getEnableAttachmentProjections() const;
 
      void setAttachmentMinimumProjectionsSpeed( agx::Real minimumProjectionsSpeed );
 
      agx::Real getAttachmentMinimumProjectionsSpeed() const;
 
      DOXYGEN_END_INTERNAL_BLOCK()
 
    protected:
      struct InternalState
      {
        enum Flag : UInt16
        {
          ATTACHMENT_PROJECTIONS_ENABLED = 1 << 0,
          // By default, body 1 is reference and body 2 is projected to
          // the frame of body 1. This option enables for projection of
          // body 1 to the constraint frame of body 2.
          ATTACHMENT_PROJECTIONS_PROJECT_BODY_1 = 1 << 1,
        };
        using Flags = BitState<Flag, std::underlying_type_t<Flag>>;
 
        Flags flags;
        agx::Real minimumProjectionSpeed = 15.0; 
      };
 
    protected:
      AttachmentRef  m_attachments[ 2 ];
      agx::Vec3      m_transformed[ NUM_ELEMENTS ];
      CustomDataRef  m_customData;
      AngleContainer m_angles;
      InternalState  m_state;
  };
 
  AGX_FORCE_INLINE const Vec3& Attachment::get( Transformed entry ) const
  {
    return m_transformed[ entry ];
  }
 
  AGX_FORCE_INLINE Frame* Attachment::getFrame() const
  {
    return m_relFrame;
  }
 
  template<typename T>
  AGX_FORCE_INLINE Bool Attachment::is() const
  {
    return dynamic_cast<const T*>( this ) != nullptr;
  }
 
  template<>
  AGX_FORCE_INLINE Bool Attachment::is<Attachment>() const
  {
    return true;
  }
 
  template<typename T>
  AGX_FORCE_INLINE T* Attachment::as()
  {
    // Compiler warns on 'this == nullptr' because it is illegal to call member
    // functions on nullptr. However, if it helps us find a nullptr dereference
    // earlier, and with an assert instead of segmentation fault, then I think
    // it's ok to leave the check.
    #include <agx/PushDisableWarnings.h>
    agxAssert( (void *)this == nullptr || this->is<T>() );
    return static_cast<T*>( this );
    #include <agx/PopDisableWarnings.h>
  }
 
  template<typename T>
  AGX_FORCE_INLINE T* Attachment::safeAs()
  {
    return dynamic_cast<T*>( this );
  }
 
  template<typename T>
  AGX_FORCE_INLINE const T* Attachment::as() const
  {
    // Compiler warns on 'this == nullptr' because it is illegal to call member
    // functions on nullptr. However, if it helps us find a nullptr dereference
    // earlier, and with an assert instead of segmentation fault, then I think
    // it's ok to leave the check.
    #include <agx/PushDisableWarnings.h>
    agxAssert( (void *)this == nullptr || this->is<T>() ); return static_cast<const T*>( this );
    #include <agx/PopDisableWarnings.h>
  }
 
  template<typename T>
  AGX_FORCE_INLINE const T* Attachment::safeAs() const
  {
    return dynamic_cast<const T*>( this );
  }
 
  AGX_FORCE_INLINE RigidBody* RigidBodyAttachment::getRigidBody() const
  {
    return m_rb;
  }
 
  AGX_FORCE_INLINE Attachment* AttachmentPair::operator[]( UInt i ) const
  {
    agxAssert( i < 2 );
    return m_attachments[ i ].get();
  }
 
  inline Attachment* AttachmentPair::getAttachment1() const
  {
    return (*this)[ 0 ];
  }
 
  inline Attachment* AttachmentPair::getAttachment2() const
  {
    return (*this)[ 1 ];
  }
 
  AGX_FORCE_INLINE const Vec3& AttachmentPair::get( Transformed entry ) const
  {
    return m_transformed[ entry ];
  }
} // namespace agx
 
#ifdef _MSC_VER
#pragma warning( pop )
#endif