StrongInteraction.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/Interaction.h>
 
#if defined(_MSC_VER)
#pragma warning( push )
#pragma warning( disable : 4589 ) // Disable: 4589: Constructor of abstract class 'agx::FrictionModel' ignores initializer for virtual base class 'agxStream::Serializable'
#endif
 
 
namespace agxRender
{
  class RenderManager;
}
 
namespace agx
{
  class SparseRangeReal;
 
  AGX_DECLARE_POINTER_TYPES( StrongInteraction );
 
  class AGXPHYSICS_EXPORT StrongInteraction : public agx::Interaction
  {
    public:
 
#if (!defined SWIG ) || (!defined SWIGCSHARP && !defined SWIGJAVA)
      struct AGXPHYSICS_EXPORT MatrixData
      {
        MatrixData( agx::Physics::RigidBodyPtr rb ) : rb( rb ), data( nullptr ), writeTranspose( false ), leadingDimension( agx::InvalidIndex ), blockRowIndex( agx::InvalidIndex ) {}
 
        template< typename T >
        void plusEqual( const T& rhs, const agx::UInt numRows, const agx::UInt numCols );
 
        agx::Physics::RigidBodyPtr rb;
        agx::Real*                 data;
        bool                       writeTranspose;
        unsigned int               leadingDimension; // Argument to Sabre, has to be 'unsigned int'.
        agx::UInt                  blockRowIndex;
      };
#endif
 
    public:
      void setEnable( agx::Bool enable );
 
      agx::Bool getEnable() const;
 
      agx::Bool getValid() const;
 
    public:
      virtual agx::RigidBody* getRigidBody1() const = 0;
 
      virtual agx::RigidBody* getRigidBody2() const = 0;
 
      virtual void addNotification() override;
 
      virtual void removeNotification() override;
 
      virtual void preSystemCallback( agx::DynamicsSystem* dynamicsSystem ) override;
 
      virtual void postSystemCallback( agx::DynamicsSystem* dynamicsSystem ) override;
 
      virtual void render( agxRender::RenderManager* mgr, float scale );
 
      virtual void prepare();
 
#if (!defined SWIG ) || (!defined SWIGCSHARP && !defined SWIGJAVA)
      virtual void writeMatrixData( agx::StrongInteraction::MatrixData rb1DiagonalBlock,
                                    agx::StrongInteraction::MatrixData rb2DiagonalBlock,
                                    agx::StrongInteraction::MatrixData offDiagonalBlock ) = 0;
 
      virtual void writeRhs( agx::Physics::RigidBodyPtr rb1,
                             agx::Real* rb1Rhs,
                             agx::Physics::RigidBodyPtr rb2,
                             agx::Real* rb2Rhs,
                             agx::Bool isRestingSolve ) = 0;
#endif
 
      virtual void addNlCallbacks( agx::SparseRangeReal& sparseRangeReal ) const;
 
      AGXSTREAM_DECLARE_ABSTRACT_SERIALIZABLE( agx::StrongInteraction );
 
    protected:
      StrongInteraction();
 
      virtual ~StrongInteraction();
 
      void setValid( agx::Bool valid );
 
      virtual void store( agxStream::OutputArchive& out ) const override;
 
      virtual void restore( agxStream::InputArchive& in ) override;
 
    private:
      Bool                m_valid;
      Bool                m_enable;
  };
 
  template< typename T >
  void StrongInteraction::MatrixData::plusEqual( const T& rhs, const agx::UInt numRows, const agx::UInt numCols )
  {
    agxAssert( data != nullptr );
    if ( writeTranspose )
      for ( agx::UInt i = 0; i < numRows; ++i )
        for ( agx::UInt j = 0; j < numCols; ++j )
          data[ j * leadingDimension + i ] += rhs[ i ][ j ];
    else
      for ( agx::UInt i = 0; i < numRows; ++i )
        for ( agx::UInt j = 0; j < numCols; ++j )
          data[ i * leadingDimension + j ] += rhs[ i ][ j ];
  }
}
 
#if defined(_MSC_VER)
#pragma warning( pop ) // restoring: warning( disable : 4127 )
#endif