ElementaryConstraint.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/ElementaryConstraintData.h>
#include <agx/RegularizationParameters.h>
#include <agx/Jacobian.h>
#include <agx/BitState.h>
 
#include <agxStream/Serializable.h>
 
#include <array>
 
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 6011) // Disable warningC6011: dereferencing nullptr pointer
#endif
 
namespace agxStream
{
  class OutputArchive;
  class InputArchive;
}
 
namespace agx
{
  class RigidBody;
  class Frame;
  class ConstraintNlmcpCallback;
 
  DOXYGEN_START_INTERNAL_BLOCK()
  namespace GWriteState
  {
    enum Enum { NORMAL, IGNORE_FIRST, WRITE_SECOND_FIRST };
  }
  DOXYGEN_END_INTERNAL_BLOCK()
 
  
  class CALLABLE AGXPHYSICS_EXPORT ElementaryConstraint : public agx::Referenced, public agxStream::Serializable
  {
    public:
      typedef agx::Vector<agx::ref_ptr<agx::ElementaryConstraint>> RefContainer;
      typedef agx::VectorPOD<agx::ElementaryConstraint*> PtrContainer;
      typedef agx::Name NameType;
 
    public:
      agx::RegularizationParameters*       getRegularizationParameters( const agx::UInt row = 0 );
 
      const agx::RegularizationParameters* getRegularizationParameters( const agx::UInt row = 0 ) const;
 
      void setCompliance( agx::Real compliance, int row );
      void setCompliance( agx::Real compliance );
 
      void setElasticity(agx::Real elasticity, int row);
      void setElasticity(agx::Real elasticity);
 
      agx::Real getCompliance( agx::UInt row = 0 ) const;
 
      agx::Real getElasticity(agx::UInt row = 0) const;
 
      void setDamping( agx::Real damping, int row );
      void setDamping( agx::Real damping );
 
      agx::Real getDamping( agx::UInt row = 0 ) const;
 
      agx::UInt getNumRows() const;
 
      void setForceRange( agx::RangeReal forceRange, const agx::UInt row = 0 );
 
      void setForceRange( agx::Real lower, agx::Real upper, const agx::UInt row = 0 );
 
      agx::RangeReal&       getForceRange( const agx::UInt row = 0 );
 
      const agx::RangeReal& getForceRange( const agx::UInt row = 0 ) const;
 
      void setName( const agx::ElementaryConstraint::NameType& name );
 
      const agx::ElementaryConstraint::NameType& getName() const;
 
      const agx::Real* getCurrentForces() const;
 
      virtual agx::Real getCurrentForce( const agx::UInt row = 0 ) const;
 
      virtual void setEnable( agx::Bool enable );
 
      virtual agx::Bool getEnable() const;
 
      virtual agx::Bool isActive() const;
 
      virtual void prepare();
 
      void reset();
 
      virtual agx::Bool isImpacting() const;
 
      virtual agx::UInt getJacobian( agx::Jacobian6DOFElement* G, agx::UInt numBlocks, agx::UInt row, agx::GWriteState::Enum writeState );
 
      virtual agx::UInt getViolation( agx::Real* g, agx::UInt row );
 
      virtual agx::UInt getVelocity( agx::Real* v, agx::UInt row ) const;
 
      virtual agx::UInt getBounds( agx::RangeReal* bounds, agx::UInt row, agx::Real h ) const;
 
      virtual void linearizeCompliance(const agx::Real* violations, agx::Real* epsilons, agx::Real minPerturbation) const;
 
#ifndef SWIG
      virtual agx::ConstraintNlmcpCallback* getNlCallback() const;
#endif
 
      virtual agx::UInt postSolveCallback( const agx::Real* solution, agx::UInt row, agx::Real h );
 
      virtual void setAttachmentPair( const agx::AttachmentPair* ap );
 
      virtual void store( agxStream::OutputArchive& out ) const override;
 
      virtual void restore( agxStream::InputArchive& in ) override;
 
      AGXSTREAM_DECLARE_ABSTRACT_SERIALIZABLE( agx::ElementaryConstraint );
 
      virtual void storeLightData( agxStream::StorageStream& str ) const override;
 
      virtual void restoreLightData( agxStream::StorageStream& str ) override;
 
      void copyRowFrom(const ElementaryConstraint* source, agx::UInt sourceRow, agx::UInt destRow);
 
    protected:
      ElementaryConstraint( agx::Bool enable,
                            agx::UInt numRows,
                            agx::RegularizationParameters* regParamsBuffer,
                            agx::Real* lastForcesBuffer,
                            agx::RangeReal* userBoundsBuffer );
 
      virtual ~ElementaryConstraint();
 
    protected:
      agx::Bool                           m_enable;         
      agx::UInt                           m_numRows;        
      agx::ElementaryConstraint::NameType m_name;           
      agx::RegularizationParameters*      m_rps;            
      agx::Real*                          m_lfs;            
      agx::RangeReal*                     m_ubs;            
      agx::ref_ptr<agx::Referenced>       m_internalData;   
    private:
      DOXYGEN_START_INTERNAL_BLOCK()
 
      friend class InternalData;
 
      agx::Referenced* getInternalData() const;
 
      void setInternalData( agx::Referenced* data );
 
      DOXYGEN_END_INTERNAL_BLOCK()
  };
 
  typedef agx::ref_ptr<ElementaryConstraint> ElementaryConstraintRef;
 
  template<size_t N>
  struct ElementaryRowData
  {
    static constexpr size_t NumRows = N;
 
    using RealData = std::array<agx::Real, NumRows>;
    using BoundData = std::array<agx::RangeReal, NumRows>;
    using RegData = std::array<agx::RegularizationParameters, NumRows>;
 
    RegData m_rpData;
    RealData m_lfData;
    BoundData m_bData;
  };
 
  template<agx::UInt N>
  class ElementaryConstraintN : public ElementaryConstraint
  {
    public:
      ElementaryConstraintN( agx::Bool enable )
        : ElementaryConstraint( enable,
                                N,
                                m_regParams,
                                m_forces,
                                m_bounds )
      {
      }
 
    protected:
      ElementaryConstraintN()
        : ElementaryConstraint( false,
                                N,
                                m_regParams,
                                m_forces,
                                m_bounds )
      {
      }
 
    protected:
      agx::RegularizationParameters m_regParams[ N ]; 
      agx::Real                     m_forces[ N ];    
      agx::RangeReal                m_bounds[ N ];    
  };
 
#ifdef SWIG
  %template(ElementaryConstraint1) agx::ElementaryConstraintN<1>;
  %template(ElementaryConstraint3) agx::ElementaryConstraintN<3>;
#endif
 
  template<agx::UInt N, typename DataT>
  class ElementaryConstraintNData : public ElementaryConstraintN<N>
  {
    public:
      ElementaryConstraintNData( const DataT& data, agx::Bool enable )
        : ElementaryConstraintN<N>( enable )
        , m_data( data )
      {
      }
 
      const DataT& getData() const { return m_data; }
 
      DataT& getData() { return m_data; }
 
      ElementaryConstraintNData( const ElementaryConstraintNData& ) = delete;
      ElementaryConstraintNData& operator=( const ElementaryConstraintNData& ) = delete;
 
    public:
      virtual void setAttachmentPair( const agx::AttachmentPair* ap ) override { m_data.set( ap ); }
 
    protected:
      ElementaryConstraintNData()
        : ElementaryConstraintN<N>()
        , m_data()
      {
      }
 
    protected:
      DataT m_data; 
  };
 
#ifdef SWIG
  %template(Dot11Dot1Data) agx::ElementaryConstraintNData<1, agx::Dot1Data>;
#endif
 
  class AGXPHYSICS_EXPORT Dot1 : public ElementaryConstraintNData<1, Dot1Data>
  {
    public:
      Dot1( const agx::Dot1Data& data );
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agx::Dot1);
 
    protected:
      Dot1();
 
      virtual ~Dot1();
 
      virtual agx::UInt getJacobian( agx::Jacobian6DOFElement* G, agx::UInt numBlocks, agx::UInt row, agx::GWriteState::Enum writeState ) override;
      virtual agx::UInt getViolation( agx::Real* g, agx::UInt row ) override;
  };
 
  typedef agx::ref_ptr<Dot1> Dot1Ref;
 
  class AGXPHYSICS_EXPORT Swing : public ElementaryConstraintNData<2, SwingData> {
    public:
      Swing(const agx::SwingData& data);
 
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agx::Swing );
 
    protected:
      Swing();
 
      virtual ~Swing();
 
      virtual agx::UInt getJacobian(agx::Jacobian6DOFElement* G, agx::UInt numBlocks, agx::UInt row,
                                    agx::GWriteState::Enum writeState) override;
 
      virtual agx::UInt getViolation(agx::Real* g, agx::UInt row) override;
 
      agx::Real m_sinc;
      agx::Real m_xi;
      agx::Real m_epsilon;
 
  };
 
  typedef agx::ref_ptr<Swing> SwingRef;
 
 
#ifdef SWIG
  %template(Dot21Dot2Data) agx::ElementaryConstraintNData<1, agx::Dot2Data>;
#endif
 
  class AGXPHYSICS_EXPORT Dot2 : public ElementaryConstraintNData<1, Dot2Data>
  {
    public:
      Dot2( const agx::Dot2Data& data );
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agx::Dot2);
 
    protected:
      Dot2();
 
      virtual ~Dot2();
 
      virtual agx::UInt getJacobian( agx::Jacobian6DOFElement* G, agx::UInt numBlocks, agx::UInt row, agx::GWriteState::Enum writeState ) override;
      virtual agx::UInt getViolation( agx::Real* g, agx::UInt row ) override;
  };
 
  typedef agx::ref_ptr<Dot2> Dot2Ref;
 
#ifdef SWIG
  %template(ElementaryConstraint3ElementaryConstraintData) agx::ElementaryConstraintNData<3, agx::ElementaryConstraintData>;
#endif
 
  class AGXPHYSICS_EXPORT Spherical : public ElementaryConstraintNData<3, ElementaryConstraintData>
  {
    public:
      Spherical( const agx::ElementaryConstraintData& data );
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agx::Spherical);
 
    protected:
      Spherical();
 
      virtual ~Spherical();
 
      virtual agx::UInt getJacobian( agx::Jacobian6DOFElement* G, agx::UInt numBlocks, agx::UInt row, agx::GWriteState::Enum writeState ) override;
      virtual agx::UInt getViolation( agx::Real* g, agx::UInt row ) override;
  };
 
  typedef agx::ref_ptr<Spherical> SphericalRef;
 
  class AGXPHYSICS_EXPORT SphericalRel : public ElementaryConstraintNData<3, ElementaryConstraintData>
  {
    public:
      SphericalRel( const agx::ElementaryConstraintData& data );
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agx::SphericalRel);
 
    protected:
      SphericalRel();
 
      virtual ~SphericalRel();
 
      virtual agx::UInt getJacobian( agx::Jacobian6DOFElement* G, agx::UInt numBlocks, agx::UInt row, agx::GWriteState::Enum writeState ) override;
      virtual agx::UInt getViolation( agx::Real* g, agx::UInt row ) override;
  };
 
  typedef agx::ref_ptr<SphericalRel> SphericalRelRef;
 
#ifdef SWIG
  %template(QuatLock3QuatLockData) agx::ElementaryConstraintNData<3, agx::QuatLockData>;
#endif
 
  class AGXPHYSICS_EXPORT QuatLock : public ElementaryConstraintNData<3, QuatLockData>
  {
    public:
      QuatLock( const agx::QuatLockData& data );
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agx::QuatLock);
 
    protected:
      QuatLock();
 
      virtual ~QuatLock();
 
      virtual void setAttachmentPair( const agx::AttachmentPair* ap ) override;
 
      virtual agx::UInt getJacobian( agx::Jacobian6DOFElement* G, agx::UInt numBlocks, agx::UInt row, agx::GWriteState::Enum writeState ) override;
      virtual agx::UInt getViolation( agx::Real* g, agx::UInt row ) override;
 
      virtual void linearizeCompliance(const agx::Real* violations, agx::Real* epsilons, agx::Real minPerturbation) const override;
  };
 
  typedef agx::ref_ptr<QuatLock> QuatLockRef;
 
#ifdef SWIG
  %template(BasicControllerConstraint1ConstraintAngleBasedData) agx::ElementaryConstraintNData<1, agx::ConstraintAngleBasedData>;
#endif
 
  class CALLABLE AGXPHYSICS_EXPORT BasicControllerConstraint : public ElementaryConstraintNData<1, ConstraintAngleBasedData>
  {
    public:
      BasicControllerConstraint( const agx::ConstraintAngleBasedData& data, agx::Bool enable );
 
      AGXSTREAM_DECLARE_ABSTRACT_SERIALIZABLE( agx::BasicControllerConstraint );
 
    protected:
      BasicControllerConstraint();
 
      virtual void store( agxStream::OutputArchive& out ) const override;
 
      virtual void restore( agxStream::InputArchive& in ) override;
 
      virtual agx::UInt getJacobian( agx::Jacobian6DOFElement* G,
                                     agx::UInt numBlocks,
                                     agx::UInt row,
                                     agx::GWriteState::Enum writeState ) override;
 
      virtual agx::UInt writeJacobian( agx::Jacobian6DOFElement* G,
                                       agx::UInt numBlocks,
                                       agx::UInt row,
                                       agx::GWriteState::Enum writeState,
                                       const agx::Vec3& dir1,
                                       const agx::Vec3& dir2,
                                       agx::Angle::Type type ) const;
  };
 
  class CALLABLE AGXPHYSICS_EXPORT TargetSpeedController : public BasicControllerConstraint
  {
    public:
      TargetSpeedController( const agx::ConstraintAngleBasedData& data );
 
      void setSpeed( agx::Real speed );
 
      agx::Real getSpeed() const;
 
      void setLocked( agx::Bool locked );
 
      agx::Bool getLocked() const;
 
      void setLockedAtZeroSpeed( agx::Bool lockedAtZeroSpeed );
 
      agx::Bool getLockedAtZeroSpeed() const;
 
      static agx::TargetSpeedController* safeCast( const agx::ElementaryConstraint* targetSpeedController );
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agx::TargetSpeedController);
 
      virtual void storeLightData( agxStream::StorageStream& str ) const override;
 
      virtual void restoreLightData( agxStream::StorageStream& str ) override;
 
    protected:
      enum InternalState { NONE = 0, LOCKED = (1<<0), LOCKED_AT_ZERO_SPEED = (1<<1) };
 
    protected:
      TargetSpeedController();
 
      virtual ~TargetSpeedController();
 
      void adjustToCurrentState();
 
      agx::Bool isLocked() const;
 
      virtual agx::UInt getViolation( agx::Real* g, agx::UInt row ) override;
      virtual agx::UInt getVelocity( agx::Real* v, agx::UInt row ) const override;
 
    protected:
      agx::Real  m_speed;
      agx::Int32 m_internalState;
      agx::Real  m_lockAngle;
  };
 
  typedef agx::ref_ptr<TargetSpeedController> TargetSpeedControllerRef;
 
  class AGXPHYSICS_EXPORT FrictionController : public BasicControllerConstraint
  {
    public:
      FrictionController( const agx::ConstraintAngleBasedData& data );
 
      void setFrictionCoefficient( agx::Real frictionCoefficient );
 
      agx::Real getFrictionCoefficient() const;
 
      void setEnableNonLinearDirectSolveUpdate( agx::Bool enable );
 
      agx::Bool getEnableNonLinearDirectSolveUpdate() const;
 
      void setMinimumStaticFrictionForceRange( agx::RangeReal bound );
 
      agx::RangeReal getMinimumStaticFrictionForceRange() const;
 
      virtual agx::Bool isActive() const override;
 
      static agx::FrictionController* safeCast( const agx::ElementaryConstraint* frictionController );
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agx::FrictionController );
 
      virtual void storeLightData( agxStream::StorageStream& str ) const override;
 
      virtual void restoreLightData( agxStream::StorageStream& str ) override;
 
#ifndef SWIG
    public:
      ConstraintNlmcpCallback* getNlCallback() const override;
      agx::UInt iterativePostSolveCallback( const agx::ConstraintImplementation* constraint,
                                            const agx::Real* solution,
                                            agx::UInt row,
                                            agx::Real h );
#endif
 
    protected:
      FrictionController();
      virtual ~FrictionController();
 
      virtual agx::UInt getViolation( agx::Real* g, agx::UInt row ) override;
      virtual agx::UInt getBounds( agx::RangeReal* bounds, agx::UInt row, agx::Real h ) const override;
      virtual agx::UInt postSolveCallback( const agx::Real* solution, agx::UInt row, agx::Real h ) override;
 
    private:
      enum Flag : agx::UInt16
      {
        NON_LINEAR = 1 << 0
      };
      using Flags = agx::BitState<Flag, agx::UInt16>;
 
    private:
      class FrictionControllerNlCallback* getCallback() const;
 
    private:
      Real m_frictionCoefficient;
      Real m_lastNormalForce;
      RangeReal m_minimumStaticFrictionBound;
      ref_ptr<Referenced> m_nlmcpCallback;
      Flags m_flags;
  };
 
  typedef agx::ref_ptr<FrictionController> FrictionControllerRef;
  typedef agx::SetVector<ref_ptr<FrictionController> >  FrictionControllerRefSetVector;
 
 
 
  class AGXPHYSICS_EXPORT ElectricMotorController : public BasicControllerConstraint
  {
    public:
      ElectricMotorController( const agx::ConstraintAngleBasedData& data );
 
      void setVoltage( agx::Real voltage );
 
      agx::Real getVoltage() const;
 
      void setArmatureResistance( agx::Real armatureResistance );
 
      agx::Real getArmatureResistance() const;
 
      void setTorqueConstant( agx::Real torqueConstant );
 
      agx::Real getTorqueConstant() const;
 
      static agx::ElectricMotorController* safeCast( const agx::ElementaryConstraint* electricMotorController );
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agx::ElectricMotorController);
 
      virtual void storeLightData( agxStream::StorageStream& str ) const override;
 
      virtual void restoreLightData( agxStream::StorageStream& str ) override;
 
    protected:
      ElectricMotorController();
      virtual ~ElectricMotorController();
 
      using ElementaryConstraint::setCompliance;
 
      using ElementaryConstraint::setDamping;
 
      virtual void prepare() override;
      virtual agx::UInt getViolation( agx::Real* v, agx::UInt row ) override;
      virtual agx::UInt getVelocity( agx::Real* v, agx::UInt row ) const override;
 
    protected:
      agx::Real m_voltage;
      agx::Real m_armatureResistance;
      agx::Real m_torqueConstant;
  };
 
  typedef agx::ref_ptr<ElectricMotorController> ElectricMotorControllerRef;
 
  class CALLABLE AGXPHYSICS_EXPORT RangeController : public BasicControllerConstraint
  {
    public:
      RangeController( const agx::ConstraintAngleBasedData& data );
 
      void setRange( agx::RangeReal range );
 
      void setRange( agx::Real lower, agx::Real upper );
 
      agx::RangeReal& getRange();
 
      const agx::RangeReal& getRange() const;
 
      virtual agx::Bool isActive() const override;
 
      static agx::RangeController* safeCast( const agx::ElementaryConstraint* rangeController );
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agx::RangeController);
 
      virtual void storeLightData( agxStream::StorageStream& str ) const override;
 
      virtual void restoreLightData( agxStream::StorageStream& str ) override;
 
    protected:
      RangeController();
 
      virtual ~RangeController();
 
      virtual void prepare() override;
      virtual agx::UInt getViolation( agx::Real* g, agx::UInt row ) override;
      virtual agx::UInt getBounds( agx::RangeReal* bounds, agx::UInt row, agx::Real h ) const override;
 
    protected:
      agx::RangeReal m_range;
      agx::Real      m_violation;
  };
 
  typedef agx::ref_ptr<RangeController> RangeControllerRef;
 
  class CALLABLE AGXPHYSICS_EXPORT LockController : public BasicControllerConstraint
  {
    public:
      LockController( const agx::ConstraintAngleBasedData& data );
 
      void setPosition( agx::Real position );
 
      agx::Real getPosition() const;
 
      static agx::LockController* safeCast( const agx::ElementaryConstraint* lockController );
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agx::LockController);
 
      virtual void storeLightData( agxStream::StorageStream& str ) const override;
 
      virtual void restoreLightData( agxStream::StorageStream& str ) override;
 
    protected:
      LockController();
 
      virtual ~LockController();
 
      virtual agx::UInt getViolation( agx::Real* g, agx::UInt row ) override;
 
    protected:
      agx::Real m_position;
  };
 
  typedef agx::ref_ptr<LockController> LockControllerRef;
 
  class CALLABLE AGXPHYSICS_EXPORT ScrewController : public agx::BasicControllerConstraint
  {
    public:
      ScrewController( const agx::ConstraintAngleBasedData& data );
 
      void setLead( agx::Real lead );
 
      agx::Real getLead() const;
 
      static agx::ScrewController* safeCast( const agx::ElementaryConstraint* screwController );
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agx::ScrewController);
 
      virtual void storeLightData( agxStream::StorageStream& str ) const override;
 
      virtual void restoreLightData( agxStream::StorageStream& str ) override;
 
    protected:
      ScrewController();
 
      virtual ~ScrewController();
 
      virtual agx::UInt getJacobian( agx::Jacobian6DOFElement* G, agx::UInt numBlocks, agx::UInt row, agx::GWriteState::Enum writeState ) override;
      virtual agx::UInt getViolation( agx::Real* g, agx::UInt row ) override;
 
    protected:
      agx::Real m_lead;
  };
 
 
#ifdef SWIG
  %template(TwistTwistData) agx::ElementaryConstraintNData<1, agx::TwistData>;
#endif
 
  class AGXPHYSICS_EXPORT Twist : public ElementaryConstraintNData<1, TwistData> {
    public:
      Twist(const agx::TwistData& data);
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agx::Twist );
 
    protected:
      virtual void setAttachmentPair(const agx::AttachmentPair* ap) override;
 
      Twist();
 
      virtual ~Twist();
 
      virtual agx::UInt getJacobian(agx::Jacobian6DOFElement* G, agx::UInt numBlocks, agx::UInt row,
                                    agx::GWriteState::Enum writeState) override;
 
      virtual agx::UInt getViolation(agx::Real* g, agx::UInt row) override;
  };
 
  typedef agx::ref_ptr<Twist> TwistRef;
 
 
  class AGXPHYSICS_EXPORT TwistRangeController : public Twist {
    public:
      TwistRangeController(const TwistData& data);
 
      void setRange(RangeReal range);
 
      void setRange(Real min, Real max);
 
      RangeReal& getRange();
 
      const RangeReal& getRange() const;
 
      Real getCurrentAngle();
 
      virtual Bool isActive() const override;
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agx::TwistRangeController);
 
    protected:
      virtual void setAttachmentPair(const agx::AttachmentPair* ap) override;
 
      TwistRangeController();
 
      virtual ~TwistRangeController();
 
      virtual void prepare() override;
      virtual agx::UInt getViolation(agx::Real* g, agx::UInt row) override;
      virtual agx::UInt getBounds(agx::RangeReal* bounds, agx::UInt row, agx::Real h) const override;
 
      RangeReal m_range;
      Real m_currentAngle;
      Real m_violation;
  };
 
  typedef agx::ref_ptr<TwistRangeController> TwistRangeControllerRef;
 
 
 
#ifdef SWIG
  %template(ConeLimit1ConeLimitData) agx::ElementaryConstraintNData<1, agx::ConeLimitData>;
#endif
 
  class CALLABLE AGXPHYSICS_EXPORT ConeLimit : public ElementaryConstraintNData<1, ConeLimitData>
  {
    public:
      ConeLimit(const ConeLimitData& data);
 
      void setLimitAngles(Vec2 limit);
 
      void setLimitAngles(Real a1, Real a2);
 
      void setLimitAngles(Real coneAngle);
 
      Vec2 getLimitAngles() const;
 
      Real getCurrentAngle() const;
 
      virtual Bool isActive() const override;
 
      static agx::ConeLimit* safeCast(const agx::ElementaryConstraint* coneLimit);
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agx::ConeLimit);
 
    protected:
      ConeLimit();
 
      virtual ~ConeLimit();
 
      virtual void prepare() override;
      virtual UInt getJacobian(Jacobian6DOFElement* G, UInt numBlocks, UInt row, GWriteState::Enum writeState) override;
      virtual agx::UInt getViolation(agx::Real* g, agx::UInt row) override;
      virtual agx::UInt getBounds(agx::RangeReal* bounds, agx::UInt row, agx::Real h) const override;
 
      Real m_violation;
      Real m_currentAngle;
  };
 
  typedef agx::ref_ptr<ConeLimit> ConeLimitRef;
 
 
 
  AGX_FORCE_INLINE RegularizationParameters* ElementaryConstraint::getRegularizationParameters( const UInt row /* = 0 */ )
  {
    agxAssert( m_rps != nullptr && row < m_numRows );
    return &m_rps[ row ];
  }
 
  AGX_FORCE_INLINE const RegularizationParameters* ElementaryConstraint::getRegularizationParameters( const UInt row /* = 0 */ ) const
  {
    agxAssert( m_rps != nullptr && row < m_numRows );
    return &m_rps[ row ];
  }
 
  AGX_FORCE_INLINE UInt ElementaryConstraint::getNumRows() const
  {
    return m_numRows;
  }
 
  AGX_FORCE_INLINE const ElementaryConstraint::NameType& ElementaryConstraint::getName() const
  {
    return m_name;
  }
 
  inline void ElementaryConstraint::linearizeCompliance(
      const agx::Real* /*violations*/, agx::Real* /*epsilons*/, agx::Real /*minPerturbation*/) const
  {
  }
 
  DOXYGEN_START_INTERNAL_BLOCK()
  inline Referenced* ElementaryConstraint::getInternalData() const
  {
    return m_internalData;
  }
  DOXYGEN_END_INTERNAL_BLOCK()
}
 
#ifdef _MSC_VER
# pragma warning(pop)
#endif