Link.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 <agxWire/ILinkNode.h>
#include <agxWire/WireParallelCallbacksHandler.h>
 
#define LINK_V2_SERIALIZATION_VERSION agx::UInt16( 37 )
 
namespace agxSDK
{
  class SimulationProxy;
}
 
namespace agxWire
{
  class Winch;
 
  AGX_DECLARE_POINTER_TYPES( Link );
 
  class AGXPHYSICS_EXPORT Link : public agx::Referenced, public agxStream::Serializable
  {
    public:
      AGX_DECLARE_POINTER_TYPES( Algorithm );
      typedef agx::Vector< agxWire::ILinkNodeRef > ConnectionsContainer;
      typedef agx::Vector< agxWire::LinkRef > LinkConnectionsContainer;
 
    public:
      enum ConnectionType
      {
        WIRE_BEGIN         = 0,    
        WIRE_END           = 1,    
        LINK                  ,    
        INVALID_CONNECTION = 0xFF  
      };
 
      enum class WinchState
      {
        PULLED_IN,    
        INSIDE,       
        OVERLAPPING,  
        NONE          
      };
 
    public:
      static agxWire::Wire* getWire( const agxWire::ConnectingNode* connectingNode,
                                     agx::Bool findClosestIfLinkConnections = false );
 
      static agxWire::Link* getLink( const agxWire::ConnectingNode* connectingNode );
 
      static agxWire::Link* getConnectingLink( const agxWire::ConnectingNode* connectingNode );
 
      static agxWire::Link::ConnectionType getConnectionType( const agxWire::ConnectingNode* connectingNode );
 
      static agx::Bool connect( agxWire::Wire* wire1,
                                const agx::Vec3& relativeTranslate1,
                                agxWire::Link* link,
                                agxWire::Wire* wire2,
                                const agx::Vec3& relativeTranslate2 );
 
    public:
      Link( agx::RigidBody* rb );
 
      agx::RigidBody* getRigidBody() const;
 
      agx::Bool connect( agxWire::Wire* wire, const agx::Vec3& relativeTranslate, agxWire::Link::ConnectionType type );
 
      agx::Bool connect( agxWire::Link* link, agx::Constraint* constraint );
 
      agx::Bool attach( agxWire::Wire* wire, const agx::Vec3& relativeTranslate, agxWire::Link::ConnectionType type );
 
      agx::Bool disconnect( agxWire::Wire* wire );
 
      agx::Bool disconnect( agxWire::Link* otherLink );
 
      agxWire::ILinkNode::ConnectionProperties* getDefaultWireConnectionProperties();
 
      const agxWire::ILinkNode::ConnectionProperties* getDefaultWireConnectionProperties() const;
 
      agx::Bool add( agxWire::Link::Algorithm* algorithm );
 
      agx::Bool remove( agxWire::Link::Algorithm* algorithm );
 
      template< typename T >
      T* getAlgorithm() const;
 
      void transform();
 
      agx::UInt getNumConnections() const;
 
      const agxWire::Link::ConnectionsContainer& getConnections() const;
 
      agx::Bool hasConnection( const agxWire::Wire* wire ) const;
 
      agxWire::ILinkNode* getConnectingNode( const agxWire::Wire* wire ) const;
 
      agxWire::ILinkNode* getConnectingNode( const agxWire::Link* link ) const;
 
      agx::Constraint* getConnectingConstraint( const agxWire::Link* link ) const;
 
      template<typename Pred>
      agxWire::Link::ConnectionsContainer getConnectingNodes( Pred pred ) const;
 
      template<typename Pred>
      agxWire::ILinkNode* findConnectingNode( Pred pred ) const;
 
      agx::Bool getEnable() const;
 
      void debugRenderConnections() const;
 
      WinchState findWinchState() const;
 
      agxWire::Winch* findPulledInWinch() const;
 
    DOXYGEN_START_INTERNAL_BLOCK()
    public:
      void initialize( agxSDK::SimulationProxy* simulationProxy );
 
      void setEnable( agx::Bool enable, agxSDK::SimulationProxy* simulationProxy );
 
      void onRemoveNotification( agxWire::Wire* wire, agxWire::ConnectingNode* connectingNode );
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agxWire::Link );
 
    DOXYGEN_END_INTERNAL_BLOCK()
 
    protected:
      enum State
      {
        NONE           = 0,
        INITIALIZED    = 1 << 0, 
        ENABLE_TOGGLED = 1 << 1  
      };
 
      typedef agx::Vector< agxWire::Link::AlgorithmRef > AlgorithmContainer;
 
    protected:
      Link();
 
      virtual ~Link();
 
      void collectGarbage();
 
      void addConnection( agxWire::Link::ConnectionsContainer& connections, agxWire::ILinkNode* node );
 
      void eraseConnection( agxWire::Link::ConnectionsContainer& connections, agxWire::ILinkNode* node );
 
      void addState( agxWire::Link::State state );
 
      void removeState( agxWire::Link::State state );
 
      agx::Bool hasState( agxWire::Link::State state ) const;
 
    protected:
      friend class LinkController;
 
      virtual agx::Bool executeUpdate( const agxSDK::SimulationProxy* simulationProxy );
 
      virtual void update( agxWire::WireParallelCallbacksHandler::CallbackTypes type, agxSDK::SimulationProxy* simulationProxy );
 
    protected:
      agx::RigidBodyRef               m_rb;
      AlgorithmContainer              m_algorithms;
      AlgorithmContainer              m_newlyAddedAlgorithms;
      agx::Int32                      m_state;
      ILinkNode::ConnectionProperties m_defaultWireConnectionProperties;
      ILinkNode::ConnectionProperties m_defaultLinkConnectionProperties;
 
    private:
      ConnectionsContainer            m_connections;
  };
 
  class AGXPHYSICS_EXPORT Link::Algorithm : public agx::Referenced, public agxStream::Serializable
  {
    public:
      virtual void onLinkEnable(agx::Bool enable, agxWire::Link* link, agxSDK::SimulationProxy* simulationProxy);
 
      virtual void preCollide(agxWire::Link* link, agxSDK::SimulationProxy* simulationProxy);
 
      virtual void pre(agxWire::Link* link, agxSDK::SimulationProxy* simulationProxy);
 
      virtual void post(agxWire::Link* link, agxSDK::SimulationProxy* simulationProxy);
 
      agx::Bool addChild( agxWire::Link::Algorithm* algorithm );
 
      agx::Bool removeChild( agxWire::Link::Algorithm* algorithm );
 
      agx::UInt getNumChildren() const;
 
      agxWire::Link::Algorithm* getChild( agx::UInt i ) const;
 
      agxWire::Link::Algorithm* getParent() const;
 
      void preChildrenUpdate();
 
      void postChildrenUpdate();
 
      template< typename T >
      T* find() const;
 
      template< typename T >
      const T* as() const;
 
      template< typename T >
      T* as();
 
    DOXYGEN_START_INTERNAL_BLOCK()
    public:
      virtual void store( agxStream::OutputArchive& out ) const override;
 
      virtual void restore( agxStream::InputArchive& in ) override;
 
      AGXSTREAM_DECLARE_ABSTRACT_SERIALIZABLE( Link::Algorithm );
 
    DOXYGEN_END_INTERNAL_BLOCK()
 
    protected:
      Algorithm();
 
    private:
      enum State { IDLE = 0, UPDATING_CHILDREN = (1<<0) };
 
    private:
      typedef agx::Vector< agxWire::Link::AlgorithmRef > ChildrenContainer;
 
    private:
      ChildrenContainer m_children;
      ChildrenContainer m_removedChildren;
      Link::Algorithm*  m_parent;
      agx::Int32        m_state;
  };
 
  DOXYGEN_START_INTERNAL_BLOCK()
 
  inline void Link::Algorithm::onLinkEnable(agx::Bool /*enable*/, agxWire::Link* /*link*/, agxSDK::SimulationProxy* /*simulationProxy*/) {}
 
  inline void Link::Algorithm::preCollide(agxWire::Link* /*link*/, agxSDK::SimulationProxy* /*simulationProxy*/) {}
 
  inline void Link::Algorithm::pre(agxWire::Link* /*link*/, agxSDK::SimulationProxy* /*simulationProxy*/) {}
 
  inline void Link::Algorithm::post(agxWire::Link* /*link*/, agxSDK::SimulationProxy* /*simulationProxy*/) {}
 
  template<typename T>
  T* Link::getAlgorithm() const
  {
    T* algorithm = nullptr;
    for ( agx::UInt i = 0, numAlgorithms = m_algorithms.size(); algorithm == nullptr && i < numAlgorithms; ++i )
      algorithm = m_algorithms[ i ]->find<T>();
 
    return algorithm;
  }
 
  DOXYGEN_END_INTERNAL_BLOCK()
 
  template<typename Pred>
  Link::ConnectionsContainer Link::getConnectingNodes( Pred pred ) const
  {
    ConnectionsContainer ret;
    ret.reserve( m_connections.size() );
    for ( agx::UInt i = 0, numConnections = m_connections.size(); i < numConnections; ++i )
      if ( pred( m_connections[ i ] ) )
        ret.push_back( m_connections[ i ] );
    return ret;
  }
 
  template<typename Pred>
  ILinkNode* Link::findConnectingNode( Pred pred ) const
  {
    for ( agx::UInt i = 0, numConnections = m_connections.size(); i < numConnections; ++i )
      if ( pred( m_connections[ i ] ) )
        return m_connections[ i ];
    return nullptr;
  }
 
  template<typename T>
  T* Link::Algorithm::find() const
  {
    T* algorithm = const_cast<Link::Algorithm*>( this )->as<T>();
    for ( agx::UInt i = 0; algorithm == nullptr && i < m_children.size(); ++i )
      algorithm = m_children[ i ]->find<T>();
 
    return algorithm;
  }
 
  template<typename T>
  const T* Link::Algorithm::as() const
  {
    return dynamic_cast<const T*>( this );
  }
 
  template<typename T>
  T* Link::Algorithm::as()
  {
    return dynamic_cast<T*>( this );
  }
}