agxWire/Node.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/RigidBody.h>
#include <agxCollide/Geometry.h>
 
#include <agx/List.h>
 
#include <agx/LinearProbingHashTable.h>
#include <agx/QuadraticProbingHashTable.h>
 
namespace agxWire
{
  // Forward declarations
  class Node;
  class FreeNode;
  class BodyFixedNode;
  class EyeNode;
  class ConnectingNode;
  class StopNode;
  class ContactNode;
  class ShapeContactNode;
  class WireFrictionController;
  class WireTensionController;
  class WireFrictionConstraintImplementation;
  class SpatialState;
  class Wire;
  class Link;
 
  typedef agx::HashVector< agxCollide::GeometryRef, agx::Vec3 > GeometryRefDepthTable;
  // Container typedefs
  typedef agx::ref_ptr< Node > NodeRef;
  typedef agx::List< NodeRef > NodeRefListA;
  typedef NodeRefListA NodeContainer;
  typedef NodeContainer::iterator NodeIterator;
  typedef NodeContainer::reverse_iterator NodeReverseIterator;
  typedef NodeContainer::const_reverse_iterator NodeConstReverseIterator;
  typedef NodeContainer::const_iterator NodeConstIterator;
  typedef agx::Vector<NodeRef> NodeRefVector;
 
#include <HashImplementationSwitcher.h>
#if HASH_FOR_WIRE == HASH_NEW
  using NodePtrNodeIterHash = agx::LinearProbingHashTable<Node*, NodeIterator>;
#elif HASH_FOR_WIRE == HASH_OLD
  typedef agx::QuadraticProbingHashTable< Node*, NodeIterator > NodePtrNodeIterHash;
#else
  #error
#endif
 
  typedef agx::List< Node* > NodePtrListA;
  typedef NodePtrListA NodePtrContainer;
  typedef NodePtrContainer::iterator NodePtrIterator;
  typedef NodePtrContainer::const_iterator NodePtrConstIterator;
 
  typedef agx::Vector< Node* > NodePtrVector;
 
  enum class WireGeometryType
  {
    SEGMENT,
    LUMPED_SPHERE,
    CONTACT_SENSOR
  };
 
  class AGXPHYSICS_EXPORT NodeFrame
  {
    public:
      enum Elements
      {
        ORG_TRANSLATE,      
        TRANSLATE,          
        REL_BODY_TRANSLATE, 
        ENUM_SIZE
      };
 
      NodeFrame();
 
      ~NodeFrame();
 
      agx::Vec3& getElement( Elements element );
 
      const agx::Vec3& getElement( Elements element ) const;
 
      void transform();
 
      void setTranslate( const agx::Vec3& translate );
 
      void setTranslate( agx::Real x, agx::Real y, agx::Real z );
 
      const agx::Vec3& getTranslate() const;
 
      agx::Vec3 calculateCmOffset( const agx::RigidBody* rb ) const;
 
      const agx::Vec3& getWorldPosition() const;
 
      void setRigidBody( agx::RigidBody* body );
 
      agx::RigidBody* getRigidBody() const;
 
    protected:
      agx::RigidBodyRef m_rb;
      agx::Vec3         m_data[ ENUM_SIZE ];
  };
 
  class AGXPHYSICS_EXPORT NodeMaterial
  {
    public:
      enum Direction
      {
        NEGATIVE = 0, 
        POSITIVE,     
        BOTH          
      };
 
      enum FrictionDirection
      {
        GO_FORWARD = 1,                 
        IS_DIRTY = (1<<1),              
        FIX_FRICTION_DIRECTION = (1<<2) 
      };
 
      NodeMaterial();
 
      bool hasValidRestLength() const;
 
      bool isStick() const;
 
      bool isStick( Direction dir ) const;
 
      void setActive( bool active );
 
      bool getActive() const;
 
      void setStick( bool stick, Direction dir );
 
      agx::Real getFrictionCoefficient( Direction dir ) const;
 
      agx::Real getKinematicContactNodeVelocityScale( Direction dir ) const;
 
      void setFrictionCoefficient( agx::Real coeff, Direction dir = BOTH );
 
      void setKinematicContactNodeVelocityScale( agx::Real scaler, Direction dir = BOTH );
 
      bool getEnable() const;
 
      bool isEnabled() const;
 
      Direction getActiveDirection() const;
 
      agx::Real getMaxForce( Direction dir );
 
      bool isInfCoefficient( Direction dir ) const;
 
      agx::Real getNormalForceMagnitude() const;
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
      
      void toggleGoForward();
 
      bool getGoForward() const;
 
      bool goForwardIsDirty() const;
 
      void setGoForwardIsDirty();
 
      void resetGoForwardIsDirty();
 
      void updateStick( agx::Real tension );
 
      void setInvalidRestLength();
 
      void store( agxStream::OutputArchive& out ) const;
 
      void restore( agxStream::InputArchive& in, agxWire::Node* node );
 
      void reverse();
 
      agx::Real getRestLength() const;
 
      agx::Real getViolation() const;
      DOXYGEN_END_INTERNAL_BLOCK()
 
 
    protected:
      friend class WireFrictionController;
      friend class Node;
      friend class EyeNode;
      friend class WireFrictionConstraintImplementation;
      friend class WireOldContactController;
      friend class WireDistanceCompositeConstraintImplementation;
 
      void setRestLength( agx::Real restLength );
 
      void setViolation( agx::Real violation );
 
      void setViolationPerUnitLength( agx::Real violationPerUnitLength );
 
      agx::Real getViolationPerUnitLength();
 
      void setNormalForceMagnitude( agx::Real normalForce );
 
    protected:
      enum CurrentType { VELOCITY_SCALER = 0, FRICTION_COEFFICIENT };
 
    protected:
      agx::Real m_frictionCoeffs[ 2 ][ BOTH ];  
      agx::Real m_restLength;                   
      agx::Real m_normalForceMagnitude;         
      bool m_stick[ BOTH ];                     
      char m_goForward;                         
      bool m_activeConstraint;                  
      agx::Real m_violationPerUnitLength;       
  };
 
  class AGXPHYSICS_EXPORT HighResolutionRange
  {
    public:
      HighResolutionRange();
 
      void set( agx::Real startDistance, agx::Real endDistance, agx::Real nodesPerUnitDistance );
 
      bool isActive() const;
 
      agx::Real getStartDistance() const;
 
      agx::Real getEndDistance() const;
 
      agx::Real getNodesPerUnitDistance() const;
 
      void setStartDistance( agx::Real startDistance );
 
      void setEndDistance( agx::Real endDistance );
 
      void setNodesPerUnitDistance( agx::Real nodesPerUnitDistance );
 
      void reverse();
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
      
      void store( agxStream::OutputArchive& out ) const;
 
      void restore( agxStream::InputArchive& in );
 
      DOXYGEN_END_INTERNAL_BLOCK()
 
     protected:
      agx::Real m_startDistance;
      agx::Real m_endDistance;
      agx::Real m_nodesPerUnitDistance;
  };
 
  class AGXPHYSICS_EXPORT Node : public agx::Referenced, public virtual agxStream::Serializable
  {
    public:
      enum Type
      {
        NOT_DEFINED = 0,      
        EYE         = (1<<0), 
        MISSING     = (1<<1), 
        CONNECTING  = (1<<2), 
        FREE        = (1<<3), 
        CONTACT     = (1<<4), 
        BODY_FIXED  = (1<<5), 
        STOP = (1 << 6),  
        SHAPE_CONTACT = (1<<7)  
      };
 
      enum StateInfo
      {
        STANDARD                    = 0,       
        WAS_CONTACT                 = (1<< 0), 
        IS_HIGH_RES                 = (1<< 1), 
        IGNORE_BEND                 = (1<< 2), 
        NO_LUMP_NEAR                = (1<< 3), 
        NO_CIRCLE_CONTACT           = (1<< 4), 
        GYPSY_CONTACT               = (1<< 5), 
        NO_MOVEMENT_RANGE           = (1<< 6), 
        NO_FRICTION                 = (1<< 7), 
        SPLIT_ENABLED               = (1<< 8), 
        INSIDE_OBJECT               = (1<< 9), 
        WAS_CONTACT_LAST_TIMESTEP   = (1<<10), 
        PERMANENT_LUMP              = (1<<11), 
        REPLACE_SUPERBEND_WITH_BEND = (1<<12), 
        LUMPED_NODE                 = (1<<13), 
        LUMP_CONTACT                = (1<<14), 
        WW_STABILIZED               = (1<<15)  
      };
 
    public:
      DOXYGEN_START_INTERNAL_BLOCK()
#ifndef SWIG
      class SpatialState
      {
        public:
          struct Data
          {
            Data();
 
            bool operator < ( const Data& other ) const;
 
            agx::Real t;
            agx::Vec3 pos;
          };
 
          typedef agx::VectorPOD< Data > DataContainer;
 
        public:
          SpatialState();
 
          ~SpatialState();
 
          void store( const agx::Real t, const agxWire::Node* curr );
 
          agx::Real store( const agx::Real currT, const agx::Real totLen, const agxWire::Node* curr, const agxWire::Node* next );
 
          void onInsert( agxWire::Node* prev, agxWire::Node* curr, agxWire::Node* next );
 
          void onRemove( agxWire::Node* prev, agxWire::Node* curr, agxWire::Node* next );
 
          void sort();
 
          Data* local();
 
          const Data* local() const;
 
          const DataContainer& removed() const { return m_removed; }
 
          const Data* intermediate( agx::UInt i ) const;
 
          void store( agxStream::OutputArchive& out ) const;
 
          void restore( agxStream::InputArchive& in );
 
        protected:
          Data m_local;
          DataContainer m_removed;
      };
#endif
      DOXYGEN_END_INTERNAL_BLOCK()
 
    public:
      static int findNodeState( const agxCollide::Geometry* geometry );
 
      static agx::Bool isContactType(const Node* node);
      static agx::Bool isContactType(const Node::Type& type);
 
      Node::Type getType() const;
 
      agx::Bool isType( agx::Int typeMask ) const;
 
      Type getNodeType() const;
 
      NodeFrame* getFrame();
 
      const NodeFrame* getFrame() const;
 
      NodeFrame& getNodeFrame();
 
      DOXYGEN_START_INTERNAL_BLOCK()
      SpatialState* getSpatialState();
 
      const SpatialState* getSpatialState() const;
      DOXYGEN_END_INTERNAL_BLOCK()
 
      const agx::Vec3& getWorldPosition() const;
 
      const agx::Vec3& getTranslate() const;
 
      const agx::Vec3& getPosition() const; // support old code
 
      virtual void setTranslate( const agx::Vec3& translate );
 
      void setTranslate( agx::Real x, agx::Real y, agx::Real z );
 
      agx::RigidBody* getRigidBody() const;
 
      virtual void reverse();
 
      void transform();
 
      void setCustomData( agx::Referenced* customData );
 
      agx::Referenced* getCustomData() const;
 
      HighResolutionRange* getHighResolutionRange();
 
      const HighResolutionRange* getHighResolutionRange() const;
 
      agx::Vec3 getIntegratedPosition( agx::Real t, bool onlyTranslational = true ) const;
 
      virtual agx::Vec3 getVelocity() const;
 
      void setIgnoreBend( bool ignoreBend );
 
      bool getIgnoreBend() const;
 
      int getState() const;
 
      void addState( int state );
 
      void removeState( int state );
 
      NodeMaterial* getMaterial();
 
      const NodeMaterial* getMaterial() const;
 
      FreeNode* getAsFree();
 
      const FreeNode* getAsFree() const;
 
      BodyFixedNode* getAsBodyFixed();
 
      const BodyFixedNode* getAsBodyFixed() const;
 
      EyeNode* getAsEye();
 
      const EyeNode* getAsEye() const;
 
      EyeNode* getAsEyeLineNode();
 
      const EyeNode* getAsEyeLineNode() const;
 
      ConnectingNode* getAsConnecting();
 
      const ConnectingNode* getAsConnecting() const;
 
      StopNode* getAsStop();
 
      const StopNode* getAsStop() const;
 
      ContactNode* getAsContact();
 
      const ContactNode* getAsContact() const;
 
      const ShapeContactNode* getAsShapeContact() const;
 
      ShapeContactNode* getAsShapeContact();
 
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
      void setInsideObject(bool insideObject);
 
      bool getInsideObject() const;
 
      bool getWasContact() const;
 
      bool getWasContactLastTimestep() const;
 
      void setWasContact( bool wasContact );
 
      void setWasContactLastTimestep( bool wasContact );
 
      void setNoLumpNear( bool noLumpNear );
 
      bool getNoLumpNear() const;
 
      void setNoCircleContact( bool disableCircleContact );
 
      bool getNoCircleContact() const;
 
      void setGypsyContact(bool gypsyContact);
 
      bool getGypsyContact() const;
 
      void setNoMovementRange(bool disableMovementRange);
 
      bool getNoMovementRange() const;
 
      void setNoFriction( bool noFriction );
 
      bool getNoFriction() const;
 
      void setState( int nodeState );
 
      class AGXPHYSICS_EXPORT StoreRestoreData
      {
        public:
          StoreRestoreData();
 
          bool& ignore();
          int& geometryIndex();
          bool& atBegin();
 
          bool getIgnored() const;
          int getGeometryIndex() const;
          bool getAtBegin() const;
 
          void reset();
 
        private:
          int m_geometryIndex;
          bool m_ignore;
          bool m_atBegin;
      };
 
      StoreRestoreData* getStoreRestoreData();
 
      const StoreRestoreData* getStoreRestoreData() const;
 
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agxWire::Node );
      DOXYGEN_END_INTERNAL_BLOCK()
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
    public:
      struct AGXPHYSICS_EXPORT Tension
      {
        Tension() : raw( agx::Real( 0 ) ), smoothed( agx::Real( 0 ) ) {}
        agx::Real raw;
        agx::Real smoothed;
      };
 
      Tension* getTension();
 
      const Tension* getTension() const;
 
      struct AGXPHYSICS_EXPORT ContactForce
      {
        ContactForce() {}
 
        agx::Vec3 normalForce;
        agx::Vec3 frictionForce;
      };
 
      ContactForce* getContactForce();
 
      const ContactForce* getContactForce() const;
 
      agx::Vec3 getNormalForce() const;
DOXYGEN_END_INTERNAL_BLOCK()
 
    protected:
      Node( Type type );
 
      Node();
 
      virtual ~Node();
 
    protected:
      NodeFrame                       m_nf;
      Type                            m_type;
      HighResolutionRange             m_highResolutionRange;
      NodeMaterial                    m_material;
      int                             m_nodeState;
      Tension                         m_tension;
      ContactForce                    m_contactForce;
 
      agx::ref_ptr< agx::Referenced > m_customData;
 
      FreeNode*                       m_free;
      BodyFixedNode*                  m_bodyFixed;
      EyeNode*                        m_eye;
      ConnectingNode*                 m_connecting;
      StopNode*                       m_stop;
      ContactNode*                    m_contact;
      ShapeContactNode*               m_shapeContact;
 
      StoreRestoreData                m_storeRestoreData;
      SpatialState                    m_spatialState;
 
      agx::observer_ptr< Node >       m_parent; // Pointer back if this is a child node.
 
    private:
      DOXYGEN_START_INTERNAL_BLOCK()
      friend class agx::InternalData;
      agx::Referenced* getInternalData() const;
 
      void setInternalData( agx::Referenced* data );
      DOXYGEN_END_INTERNAL_BLOCK()
 
    private:
      agx::ref_ptr<agx::Referenced> m_internalData;
  };
 
  class AGXPHYSICS_EXPORT FreeNode : public Node
  {
    public:
      FreeNode( const agx::Vec3& position );
 
      FreeNode( agx::Real x, agx::Real y, agx::Real z );
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agxWire::FreeNode);
 
    protected:
      FreeNode();
 
      virtual ~FreeNode();
 
    protected:
      void create( const agx::Vec3& position );
  };
 
  typedef agx::ref_ptr< FreeNode > FreeNodeRef;
 
  class AGXPHYSICS_EXPORT BodyFixedNode : public Node
  {
    public:
      BodyFixedNode( agx::RigidBody* rb, const agx::Vec3& relativeTranslate = agx::Vec3() );
 
      BodyFixedNode( agx::RigidBody* rb, agx::Real relTranslate_x, agx::Real relTranslate_y, agx::Real relTranslate_z );
 
      DOXYGEN_START_INTERNAL_BLOCK()
      void setRestLength( agx::Real restLength );
 
      void changeRestLength( agx::Real dl );
 
      agx::Real getRestLength() const;
 
      void setCurrentLength( agx::Real currentLength );
 
      void changeCurrentLength( agx::Real dl );
 
      agx::Real getCurrentLength() const;
 
      agx::Real getViolation() const;
 
      void setIsLumpedNode( bool lumpedNode );
 
      bool isLumpedNode() const;
 
      void setIsLumpContact( bool lumpContact );
 
      bool isLumpContact() const;
 
      void setSplitEnabled( bool splitEnabled );
 
      bool getSplitEnabled() const;
 
      void setIsHighRes( bool wasHighRes );
 
      bool getIsHighRes() const;
 
      void setPermanentLump( bool permantentLump );
 
      bool getPermanentLump() const;
 
      void setParent( ConnectingNode* connectingNode );
 
      ConnectingNode* getParent() const;
 
      DOXYGEN_END_INTERNAL_BLOCK()
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agxWire::BodyFixedNode);
 
    protected:
      BodyFixedNode();
 
      virtual ~BodyFixedNode();
 
      void create( agx::RigidBody* rb, const agx::Vec3& relativeTranslate );
 
    protected:
      agx::Real m_restLength;
      agx::Real m_currentLength;
  };
 
  typedef agx::ref_ptr< BodyFixedNode > BodyFixedNodeRef;
 
  class AGXPHYSICS_EXPORT EyeNode : public Node
  {
    public:
      EyeNode( agx::RigidBody* rb, agx::Real radius = agx::Real( 0 ) );
 
      EyeNode( agx::RigidBody* rb, const agx::Vec3& relativeTranslate, agx::Real radius = agx::Real( 0 ) );
 
      EyeNode( agx::RigidBody* rb, const agx::Vec3& relativeTranslate, const agx::Vec3& extraEyeVector, agx::Real radius = agx::Real( 0 ) );
 
      EyeNode( agx::RigidBody* rb, agx::Real relTranslate_x, agx::Real relTranslate_y, agx::Real relTranslate_z, const agx::Vec3& extraEyeVector = agx::Vec3(), agx::Real radius = agx::Real( 0 ) );
 
      void setRadius( agx::Real radius );
 
      agx::Real getRadius() const;
 
      DOXYGEN_START_INTERNAL_BLOCK()
      void setEnableReverseAddOfNormalNode( bool reverseAdd );
      DOXYGEN_END_INTERNAL_BLOCK()
 
      void setReverseAdd( bool reverseAdd );
 
      bool getReverseAdd() const;
 
      EyeNode* getChildNode();
 
      const EyeNode* getChildNode() const;
 
      EyeNode* getParentNode() const;
 
      agx::Real getDistanceToChild() const;
 
      agx::Vec3 getVectorToChild() const;
 
      void setVectorToChild( const agx::Vec3& vec );
 
      virtual void reverse() override;
 
      void setFixFrictionDirection( bool fixFrictionDirection, bool goForward );
 
      bool getFixFrictionDirection() const;
 
      agx::Real findSpeedAlongWire( const agxWire::Wire* wire ) const;
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agxWire::EyeNode);
 
    protected:
      EyeNode();
 
      EyeNode( Type type, agx::Real radius = agx::Real( 0 ) );
 
      virtual ~EyeNode();
 
      void create( agx::RigidBody* rb, const agx::Vec3& relativeTranslate, const agx::Vec3& extraEyeVector, agx::Real radius );
 
    protected:
      agx::ref_ptr< EyeNode >       m_childNode;  // Extra eye.
      bool                          m_reverseAdd;
      agx::Real                     m_radius;
      agx::Vec3                     m_normal;
  };
 
  typedef agx::ref_ptr< EyeNode > EyeNodeRef;
 
  class AGXPHYSICS_EXPORT ConnectingNode : public EyeNode
  {
    public:
      struct AGXPHYSICS_EXPORT StabilityParameters
      {
        StabilityParameters( agx::Real youngsModulus, agx::Real damping, agx::Bool active );
 
        agx::Real youngsModulus;
        agx::Real damping;
        agx::Bool active;
      };
 
    public:
      ConnectingNode( agx::RigidBody* rb, const agx::Vec3& relativeTranslate, agx::Real radius );
 
      BodyFixedNode* getCmNode() const;
 
      void setCmNode( agxWire::BodyFixedNode* cmNode );
 
      agx::Real getOffsetLength() const;
 
      void fullTransform();
 
      DOXYGEN_START_INTERNAL_BLOCK()
      void setSuperBendReplacedWithBend( bool replaceSuperBend );
 
      bool getSuperBendReplacedWithBend() const;
 
      virtual void updateConnection( agxWire::Wire* /*wire*/ ) {}
 
      virtual agxWire::ConnectingNode::StabilityParameters calculateStabilityParameters( agx::Real radius, agx::Real defaultYoungsModulus, agx::Real defaultDamping, const agxWire::Node* nodes[ 3 ], const agxWire::WireTensionController* tensionController ) const;
 
      DOXYGEN_END_INTERNAL_BLOCK()
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agxWire::ConnectingNode);
 
    protected:
      ConnectingNode();
 
      virtual ~ConnectingNode();
 
      void create( agx::RigidBody* rb, const agx::Vec3& relativeTranslate );
 
    protected:
      BodyFixedNodeRef m_cmNode;
  };
 
  typedef agx::ref_ptr< ConnectingNode > ConnectingNodeRef;
 
  class AGXPHYSICS_EXPORT StopNode : public EyeNode
  {
    public:
      StopNode( agx::RigidBody* rb, const agx::Vec3& relativeTranslate );
 
      void setNormal( agx::Vec3 normal );
 
      agx::Vec3 getNormal() const;
 
 
      DOXYGEN_START_INTERNAL_BLOCK()
      agx::Real getReferenceDistance() const;
 
      void setReferenceDistance( agx::Real referenceDistance );
 
      DOXYGEN_END_INTERNAL_BLOCK()
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agxWire::StopNode);
 
    protected:
      StopNode();
 
      virtual ~StopNode();
 
      void create( agx::RigidBody* rb, const agx::Vec3& relativeTranslate );
 
    protected:
      agx::Real m_referenceDistance;
  };
 
  typedef agx::ref_ptr< StopNode > StopNodeRef;
 
  class AGXPHYSICS_EXPORT ContactNode : public Node
  {
    public:
      enum MovementRange
      {
        MOVEMENT_RANGE_START = 1, 
        MOVEMENT_RANGE_END   = 2  
      };
 
      DOXYGEN_START_INTERNAL_BLOCK()
      class AGXPHYSICS_EXPORT MeshIndex
      {
        public:
          MeshIndex();
 
          int getMeshCurrentTriangleIndex() const;
          int getMeshNextTriangleIndexStart() const;
          int getMeshNextTriangleIndexEnd() const;
          int getMeshCurrentEdgeIndex() const;
          int getMeshNextEdgeIndexStart() const;
          int getMeshNextEdgeIndexEnd() const;
          void setMeshCurrentIndex( int meshCurrentTriangleIndex, int meshCurrentEdgeIndex );
          void setMeshNextIndexStart( int meshNextTriangleIndexStart, int meshNextEdgeIndexStart );
          void setMeshNextIndexEnd( int meshNextTriangleIndexEnd, int meshNextEdgeIndexEnd );
 
          void reset();
          void store( agxStream::OutputArchive& out ) const;
          void restore( agxStream::InputArchive& in );
 
        private:
          int m_meshCurrentTriangleIndex;
          int m_meshCurrentEdgeIndex;
          int m_meshNextTriangleIndexStart;
          int m_meshNextEdgeIndexStart;
          int m_meshNextTriangleIndexEnd;
          int m_meshNextEdgeIndexEnd;
      };
 
      DOXYGEN_END_INTERNAL_BLOCK()
 
    public:
      ContactNode( agxCollide::Geometry* geometry, const agx::Vec3& shapeRelativeTranslate, const agx::Vec3& shapeEdgeStart, const agx::Vec3& shapeEdgeEnd, const agx::Vec3& shapeEdge );
 
      ContactNode( ContactNode* cn );
 
      ContactNode( agxCollide::Geometry* geometry, const agx::Vec3& shapeRelativeTranslate = agx::Vec3() );
 
      agxCollide::Geometry* getGeometry() const;
 
      void setGeometry( agxCollide::Geometry* geometry );
 
      virtual void setTranslate( const agx::Vec3& shapeTranslate ) override;
 
      void setNoStickContact( bool noStickyContact );
 
      bool getNoStickContact() const;
 
      MeshIndex* getMeshIndex();
 
      const MeshIndex* getMeshIndex() const;
 
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
      agxCollide::Geometry* getNextGeometry() const;
 
      void setNextGeometry(agxCollide::Geometry* nextGeometry);
 
      const agx::Vec3& getShapeTranslate() const;
 
      void setShapeEdge(const agx::Vec3& shapeEdge);
 
      const agx::Vec3& getShapeEdge() const;
 
      void resetMovementRange(int direction);
 
      void setMovementRange(const agx::Vec3& start, const agx::Vec3& end);
 
      void getMovementRange(agx::Vec3& start, agx::Vec3& end) const;
 
      void getFullMovementRange(agx::Vec3& start, agx::Vec3& end) const;
 
      bool getIfOpenAngle() const;
 
      void setOpenAngle(bool openAngle);
 
      size_t getClampedRangeInformation() const;
 
      const agx::Vec3& getPreviousPosition() const;
 
      void setPreviousPosition(agx::Real t, agx::Vec3 start, agx::Vec3 edge);
 
      void resetPreviousPosition();
 
      bool clampMovementRange(const agx::Vec3& pos, MovementRange direction);
 
      void setShapeEdgeOffset(const agx::Vec3& offset);
 
      agx::Vec3 getShapeEdgeOffset() const;
 
      void setCollidedGeometry(agxCollide::Geometry* geometry, const agx::Vec3& depthVector);
 
      const GeometryRefDepthTable& getCollidedGeometries() const;
 
      void resetCollidedGeometries();
 
      agx::Vec3 getParameterizedPosition(agx::Real t) const;
 
      agx::Real findParameterizedValue(agx::Vec3 localPosition) const;
 
      agx::Real findParameterizedValueFullRange(agx::Vec3 localPosition) const;
 
 
      void analyzeCollidedGeometries();
 
      void copyGeometries(agxWire::ContactNode* cn);
 
      agx::Real getEdgeVelocity() const;
 
      void setEdgeVelocity(agx::Real vel);
 
      bool getCreatedFromDynamicContact() const;
 
      bool onSameGeometry( const agxWire::NodeConstIterator otherNodeIt ) const;
 
      bool onSameGeometry( const agxWire::Node* otherNode ) const;
 
      bool initialize( agx::Real wireRadius, agx::Real wireRadiusMultiplier );
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agxWire::ContactNode);
 
      DOXYGEN_END_INTERNAL_BLOCK()
 
 
    protected:
      ContactNode();
 
      virtual ~ContactNode();
 
      void create( agxCollide::Geometry* geometry, const agx::Vec3& shapeRelativeTranslate, const agx::Vec3& shapeEdgeStart, const agx::Vec3& shapeEdgeEnd, const agx::Vec3& shapeEdge );
 
    protected:
      agx::observer_ptr< agxCollide::Geometry > m_geometry;
      agx::observer_ptr< agxCollide::Geometry > m_nextGeometry;
      agx::Vec3                                 m_shapeTranslate;
      agx::Vec3                                 m_shapeEdgeStart;
      agx::Vec3                                 m_shapeEdgeEnd;
      agx::Vec3                                 m_shapeEdge;
      agx::Vec3                                 m_shapeFullRangeStart;
      agx::Vec3                                 m_shapeFullRangeEnd;
      agx::Vec3                                 m_shapePreviousPosition;
      agx::Vec3                                 m_edgeOffsetFromSurface;
      GeometryRefDepthTable                     m_collidedGeometries;
      size_t                                    m_clamped;
      bool                                      m_openAngle;
      agx::Real                                 m_edgeVelocity;
      MeshIndex                                 m_meshIndex;
  };
 
  AGX_FORCE_INLINE const agx::Vec3& NodeFrame::getWorldPosition() const
  {
    return m_data[ TRANSLATE ];
  }
 
  AGX_FORCE_INLINE agx::RigidBody* NodeFrame::getRigidBody() const
  {
    return m_rb;
  }
 
  DOXYGEN_START_INTERNAL_BLOCK()
  AGX_FORCE_INLINE const Node::SpatialState::Data* Node::SpatialState::intermediate( agx::UInt i ) const
  {
    return i < m_removed.size() ? m_removed.ptr() + i : i == m_removed.size() ? &m_local : nullptr;
  }
 
  AGX_FORCE_INLINE Node::SpatialState::Data* agxWire::Node::SpatialState::local()
  {
    return &m_local;
  }
 
  AGX_FORCE_INLINE const Node::SpatialState::Data* agxWire::Node::SpatialState::local() const
  {
    return &m_local;
  }
 
  AGX_FORCE_INLINE agxWire::Node::SpatialState* Node::getSpatialState()
  {
    return &m_spatialState;
  }
 
  AGX_FORCE_INLINE const agxWire::Node::SpatialState* Node::getSpatialState() const
  {
    return &m_spatialState;
  }
 
  inline agx::Referenced* Node::getInternalData() const
  {
    return m_internalData;
  }
 
  DOXYGEN_END_INTERNAL_BLOCK()
 
  AGX_FORCE_INLINE Node::Type Node::getType() const
  {
    return m_type;
  }
 
  AGX_FORCE_INLINE agx::Bool Node::isType( agx::Int typeMask ) const
  {
    return (agx::Int( m_type ) & typeMask) != 0;
  }
 
  AGX_FORCE_INLINE NodeFrame* Node::getFrame()
  {
    return &m_nf;
  }
 
  AGX_FORCE_INLINE const NodeFrame* Node::getFrame() const
  {
    return &m_nf;
  }
 
  AGX_FORCE_INLINE const agx::Vec3& Node::getWorldPosition() const
  {
    return m_nf.getWorldPosition();
  }
 
  AGX_FORCE_INLINE agx::RigidBody* Node::getRigidBody() const
  {
    return m_nf.getRigidBody();
  }
 
  AGX_FORCE_INLINE BodyFixedNode* Node::getAsBodyFixed()
  {
    return m_bodyFixed;
  }
 
  AGX_FORCE_INLINE const BodyFixedNode* Node::getAsBodyFixed() const
  {
    return m_bodyFixed;
  }
 
  AGX_FORCE_INLINE EyeNode* Node::getAsEye()
  {
    return m_eye;
  }
 
  AGX_FORCE_INLINE const EyeNode* Node::getAsEye() const
  {
    return m_eye;
  }
 
  AGX_FORCE_INLINE ConnectingNode* Node::getAsConnecting()
  {
    return m_connecting;
  }
 
  AGX_FORCE_INLINE const ConnectingNode* Node::getAsConnecting() const
  {
    return m_connecting;
  }
 
  AGX_FORCE_INLINE StopNode* Node::getAsStop()
  {
    return m_stop;
  }
 
  AGX_FORCE_INLINE const StopNode* Node::getAsStop() const
  {
    return m_stop;
  }
 
  AGX_FORCE_INLINE ContactNode* Node::getAsContact()
  {
    return m_contact;
  }
 
  AGX_FORCE_INLINE const ContactNode* Node::getAsContact() const
  {
    return m_contact;
  }
 
  AGX_FORCE_INLINE const ShapeContactNode* Node::getAsShapeContact() const
  {
    return m_shapeContact;
  }
 
  AGX_FORCE_INLINE ShapeContactNode* Node::getAsShapeContact()
  {
    return m_shapeContact;
  }
 
  AGX_FORCE_INLINE ContactNode::MeshIndex* ContactNode::getMeshIndex()
  {
    return &m_meshIndex;
  }
 
  AGX_FORCE_INLINE const ContactNode::MeshIndex* ContactNode::getMeshIndex() const
  {
    return &m_meshIndex;
  }
 
  typedef agx::ref_ptr< ContactNode > ContactNodeRef;
 
}