Wire.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/WireParameterController.h>
 
#include <agxWire/WireRouteController.h>
#include <agxWire/WireInitializationController.h>
#include <agxWire/WireWinchController.h>
#include <agxWire/WireStabilityController.h>
#include <agxWire/WireMaterialController.h>
#include <agxWire/WireGeometryController.h>
#include <agxWire/WireFrictionController.h>
#include <agxWire/WireSimplifyController.h>
#include <agxWire/WireTensionData.h>
 
#include <agxWire/WireSimulationProxy.h>
#include <agxWire/RenderIterator.h>
 
#include <agx/ICloneable.h>
 
namespace agxUtil
{
  class SmoothingFilter;
}
 
namespace agx
{
  class SolveIslandSplitAlgorithm;
 
  namespace Physics
  {
    class GraphNodeData;
  }
}
 
namespace agxWire
{
  class Winch;
  AGX_DECLARE_POINTER_TYPES( Wire );
  AGX_DECLARE_VECTOR_TYPES( Wire );
 
  class AGXPHYSICS_EXPORT Wire : public SimulationProxyT< agxSDK::StepEventListener >
  {
    public:
      typedef SimulationProxyT< agxSDK::StepEventListener > base;
 
    public:
      struct AGXPHYSICS_EXPORT TensionData
      {
        TensionData();
        TensionData( agx::Real rawTension, agx::Real smoothedTension );
        TensionData( const agxWire::Node::Tension* tension );
 
        agx::Real raw;
        agx::Real smoothed;
      };
 
    public:
 
      agx::Real getContactNodeMomentum() const;
 
      static agx::Bool isLumpedNode( const agx::RigidBody* rb );
 
      static agxWire::BodyFixedNode* getLumpedNode( agx::RigidBody* rb );
 
      static const agxWire::BodyFixedNode* getLumpedNode( const agx::RigidBody* rb );
 
      static agxWire::Wire* getWire( agx::RigidBody* rb );
 
      static const agxWire::Wire* getWire( const agx::RigidBody* rb );
 
      static agxWire::Wire* getWire( agxCollide::Geometry* geometry );
 
      static const agxWire::Wire* getWire( const agxCollide::Geometry* geometry );
 
      static agxWire::Wire* find( agxSDK::Simulation* simulation, const agx::Name& name );
 
      static agxWire::Wire* find( agxSDK::Simulation* simulation, const agx::Uuid& uuid );
 
      static agxWire::WirePtrVector findAll( const agxSDK::Simulation* simulation );
 
      static agxWire::WirePtrVector findAll( const agxSDK::Simulation* simulation, const agx::Name& name );
 
    public:
      Wire( agx::Real radius, agx::Real resolutionPerUnitLength, bool enableCollisions = true );
 
      virtual agxWire::Wire* clone( agxWire::Wire* newWire = nullptr );
 
      virtual bool add( agxWire::Node* node );
 
      virtual bool add( agxWire::WireWinchController* winchController );
 
      virtual bool add( agxWire::WireWinchController* winchController, agx::Real pulledInLength );
 
      virtual bool add( agxWire::Link* link, bool updateConnectionType = true );
 
      virtual bool add( agxWire::Link* link, const agx::Vec3& relativeTranslate );
 
      virtual bool remove( agxWire::Node* node );
 
      virtual bool remove( agxWire::WireWinchController* winchController );
 
      bool insert( agxWire::Node* node, agx::Real distanceFromStart, bool includeWinchPulledInLength = true );
 
      bool insert( agxWire::Node* node, const agx::Vec3& worldPoint );
 
      bool reverse();
 
      bool merge( agxWire::WireRef other );
 
      agxWire::WireRef cut(agx::Real distanceAlongWire, size_t minimumResolution, bool includeWinchPulledInLength = true);
 
      agxWire::WireRef cut( const agx::Vec3& worldPoint, size_t minimumResolution );
 
      virtual bool attach( agxWire::Node* node, bool begin );
 
      virtual bool attach( agxWire::WireWinchController* winchController, bool begin );
 
      virtual bool detach( bool begin );
 
      const agxWire::WireAttachmentController* getBeginAttachment() const;
 
      const agxWire::WireAttachmentController* getEndAttachment() const;
 
      bool initialized() const;
 
      void setInitializationController( agxWire::WireInitializationController* initializationController );
 
      bool setRouteController( agxWire::WireRouteController* routeController, bool copyCurrentRouteToNew = false );
 
      agxWire::WireRouteController* getRouteController() const;
 
      agxWire::WireParameterController* getParameterController() const;
 
      agxWire::WireStabilityController* getStabilityController() const;
 
      agxWire::WireMaterialController* getMaterialController() const;
 
      agxWire::WireGeometryController* getGeometryController() const;
 
      agxWire::WireContactController* getActiveContactController() const;
 
      virtual agx::Real getRestLength( bool includeWinches = true ) const;
 
      agx::Real getRestLength( const agxWire::Node* node1, const agxWire::Node* node2 ) const;
 
      agx::Real findRestLength( bool includeWinches = true ) const;
 
      agx::Real getCurrentLength( bool includeWinches = true ) const;
 
      agx::Real getCurrentLength( const agxWire::Node* node1, const agxWire::Node* node2 ) const;
 
      agx::Real scaleToRestlength( agx::Real currentLength, const agxWire::Node* node ) const;
 
      agx::Real getRestLengthScaler( const agxWire::Node* node ) const;
 
      agx::Real scaleToCurrentlength( agx::Real restLength, const agxWire::Node* node ) const;
 
      agx::Real getCurrentLengthScaler( const agxWire::Node* node ) const;
 
      agxWire::WireWinchController* getWinchController( size_t i ) const;
 
      agx::Real getMass() const;
 
 
      agxWire::RenderIterator getRenderBeginIterator() const;
 
      agxWire::RenderIterator getRenderEndIterator() const;
 
      bool getRenderListEmpty() const;
 
      agx::Real findRestLengthFromStart( const agx::Vec3& point, bool includeWinchesPulledInLength = true ) const;
 
      agx::Vec3 findPoint( agx::Real distanceFromStart ) const;
 
      agx::Vec3 findPoint( agx::Real distanceFromStart, bool includesWinchesPulledInLength ) const;
 
      agx::Vec3 findPoint( const agx::Vec3& point ) const;
 
      agxWire::WireSegmentTensionData getTension( const agx::Vec3& point ) const;
 
      agxWire::WireSegmentTensionData getTension( agx::Real distanceFromStart ) const;
 
      agxWire::WireNodeTensionData getTension( const agxWire::Node* node ) const;
 
      agx::Material* getMaterial() const;
 
      virtual void setMaterial( agx::Material* material );
 
      void setIsBendResistent( bool isBendResistant );
 
      void setPropertyContainer( agx::PropertyContainer* propertyContainer );
 
      agx::PropertyContainer* getPropertyContainer();
 
      const agx::PropertyContainer* getPropertyContainer() const;
 
      bool hasPropertyContainer() const;
 
      agx::Real getRadius() const;
 
      agx::Real getRadiusIncludingContactNodeOffsetDistanceMultiplier() const;
 
      virtual void setRadius( agx::Real radius );
 
      void setResolutionPerUnitLength( agx::Real resolutionPerUnitLength );
 
      agx::Real getResolutionPerUnitLength() const;
 
      void setEnableCollisions( agxCollide::Geometry* geometry, bool enable, bool forceContactUpdate = false );
 
      void setEnableCollisions( agx::RigidBody* rb, bool enable );
 
      void setEnableCollisions( bool enable );
 
      void setActiveContactControllerType(const WireContactControllerType type);
      WireContactControllerType getActiveContactControllerType() const;
 
      bool getEnableCollisions() const;
 
      bool getEnableCollisions( const agxCollide::Geometry* geometry ) const;
 
      bool getEnableCollisions( const agx::RigidBody* rb ) const;
 
      static void setEnableGroupWireCollision(agxCollide::Space* space,const agx::UInt32 group, bool enable);
 
      void setEnableSplitting( bool splitting );
 
      bool getEnableSplitting() const;
 
      void addGroup( uint32_t id );
 
      void addGroup( const agx::Name& name );
 
      bool hasGroup( const uint32_t id ) const;
 
      bool hasGroup( const agx::Name& name ) const;
 
      void removeGroup( uint32_t id );
 
      void removeGroup( const agx::Name& name );
 
      bool hasGeometry( const agxCollide::Geometry* geometry ) const;
 
      bool hasNode( const agxWire::Node* node ) const;
 
      agxWire::Node* getFirstNode() const;
 
      agxWire::Node* getLastNode() const;
 
      agxWire::WireDistanceCompositeConstraint* getConstraint() const;
 
      void getGeometries( agxCollide::GeometryPtrVector& geoms ) const;
 
      void removeGeometries();
 
      void updateNodeTransforms();
 
      agx::Frame* getFrame() const;
 
      void setFrame( agx::Frame* frame );
 
      void setLinearVelocityDamping( agx::Real linearVelocityDamping );
 
      agx::Real getLinearVelocityDamping() const;
 
      bool hasContactNodesOn( const agx::RigidBody* rb ) const;
 
      bool hasContactNodesOn( const agxCollide::Geometry* geometry ) const;
 
      bool replaceBodyInNodes( agx::RigidBody* currentBody, agx::RigidBody* newBody, agxCollide::Geometry* geometry = nullptr );
 
      bool changeRigidBody( agxWire::Node* node, agx::RigidBody* newRigidBody ) const;
 
      void setSmoothedTension( agx::Real newSmoothedTension );
 
      void setSmoothedTension( agx::Real newSmoothedTension, agxWire::NodeIterator from, agxWire::NodeIterator to );
 
      void setSmoothingFilter( agxUtil::SmoothingFilter *filter );
 
      const agxUtil::SmoothingFilter* getSmoothingFilter() const;
 
      virtual void preCollide( const agx::TimeStamp& ) override;
 
      virtual void pre( const agx::TimeStamp& t ) override;
 
      virtual void post( const agx::TimeStamp& t ) override;
 
      bool simplify( const agx::Frame* parentFrame = nullptr );
 
      bool unsimplify();
 
      bool isSimplified() const;
 
      agxWire::WireSimplifyController* getSimplifyController() const;
 
      void setSolveType( agx::Constraint::SolveType solveType);
 
      agx::SolveIslandSplitAlgorithm* getSplitAlgorithm() const;
 
      bool shorten( const agxWire::Node* toNode, bool fromBegin );
 
      void replaceContactNodesWithShapeContacts();
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
      
      void uninitializeConstraint();
 
      bool isStatic() const;
 
      agx::UInt getNumNodes() const;
 
      bool explicitReplaceWinchController( agxWire::ConnectingNode* connectingNode, bool begin );
 
      void onCreateMergeSplitProperties();
 
      agxWire::WirePropertyController* getPropertyController() const;
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agxWire::Wire );
      DOXYGEN_END_INTERNAL_BLOCK()
 
    protected:
      Wire();
 
      virtual ~Wire();
 
      virtual void addNotification() override;
      using SimulationProxyT< agxSDK::StepEventListener >::addNotification;
 
      virtual void removeNotification() override;
      using SimulationProxyT< agxSDK::StepEventListener >::removeNotification;
 
      void updateMaterial();
 
#ifndef SWIG
      agxSDK::EventListener::Type getType() const;
#endif
 
      friend class agxWire::Winch;
      virtual void setWinchController( agxWire::WireWinchController* winchController, bool begin );
 
      agxWire::WireAttachmentController* getBeginAttachment();
 
      agxWire::WireAttachmentController* getEndAttachment();
 
    protected:
      WireDistanceCompositeConstraintRef  m_constraint;
 
      // Controllers
      WireRouteControllerRef              m_routeController;
      WireInitializationControllerRef     m_initializationController;
      WireParameterController             m_parameterController;
      WireWinchControllerRefVector        m_winchControllers;          
      WireMaterialControllerRef           m_materialController;
      WireStabilityControllerRef          m_stabilityController;
      WireGeometryControllerRef           m_geometryController;
      WireFrictionControllerRef           m_frictionController;
      WireSimplifyControllerRef           m_simplifyController;
 
      agxUtil::SmoothingFilterRef         m_smoothingFilter;
      bool                                m_initialized;
      agx::FrameRef                       m_frame;
      agx::Real                           m_linearVelocityDamping;     
      bool                                m_splitEnabled;
      agx::Constraint::SolveType          m_solveType;
 
      agx::ref_ptr<agx::Referenced>       m_splitAlgorithm;
      agx::ref_ptr<agx::Referenced>       m_internalData;
      agx::ref_ptr<agx::Referenced>       m_propertyController;
      mutable agx::PropertyContainerRef   m_propertyContainer;
 
    private:
      DOXYGEN_START_INTERNAL_BLOCK()
      friend class agx::InternalData;
      agx::Referenced* getInternalData() const;
 
      void setInternalData( agx::Referenced* data );
      DOXYGEN_END_INTERNAL_BLOCK()
  };
 
  // Inline methods *******************************************************************************************
 
  inline bool Wire::initialized() const
  {
    return m_initialized;
  }
 
  inline WireParameterController* Wire::getParameterController() const
  {
    return const_cast< WireParameterController* >( &m_parameterController );
  }
 
  inline WireRouteController* Wire::getRouteController() const
  {
    return m_routeController;
  }
 
  inline WireStabilityController* Wire::getStabilityController() const
  {
    return m_stabilityController;
  }
 
  inline WireMaterialController* Wire::getMaterialController() const
  {
    return m_materialController;
  }
 
  inline WireGeometryController* Wire::getGeometryController() const
  {
     return m_geometryController;
  }
 
  inline WireDistanceCompositeConstraint* Wire::getConstraint() const
  {
    return m_constraint;
  }
 
  inline agx::Referenced* Wire::getInternalData() const
  {
    return m_internalData;
  }
 
  AGX_FORCE_INLINE agx::PropertyContainer* Wire::getPropertyContainer()
  {
    if (!m_propertyContainer)
      m_propertyContainer = new agx::PropertyContainer;
    return m_propertyContainer;
  }
 
  AGX_FORCE_INLINE bool Wire::hasPropertyContainer() const
  {
    return (m_propertyContainer.isValid());
  }
 
  AGX_FORCE_INLINE const agx::PropertyContainer* Wire::getPropertyContainer() const
  {
    if (!m_propertyContainer)
      m_propertyContainer = new agx::PropertyContainer;
 
    return m_propertyContainer;
  }
 
  // **********************************************************************************************************
 
  // Static utility functions *********************************************************************************
  AGXPHYSICS_EXPORT void extractNodes( NodePtrVector& nodes, const Wire* wire );
  // **********************************************************************************************************
}