CollectBodiesAndWiresVisitor.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.
*/
 
#ifndef AGXUTIL_COLLECT_BODIES_AND_WIRES_VISITOR_H
#define AGXUTIL_COLLECT_BODIES_AND_WIRES_VISITOR_H
 
#include <agx/agx.h>
#include <agxWire/Wire.h>
 
namespace agxUtil {
 
  class AGXPHYSICS_EXPORT CollectBodiesAndWiresVisitor : public agxSDK::AssemblyVisitor
  {
  public:
 
    using WirePtrSetVector = agx::SetVector<agxWire::Wire*>;
    using RigidBodyPtrSetVector = agx::SetVector<agx::RigidBody*>;
    using WireNodeRefVector = agx::Vector<agxWire::NodeRef>;
 
    CollectBodiesAndWiresVisitor() {}
 
    virtual ~CollectBodiesAndWiresVisitor() {}
 
    RigidBodyPtrSetVector& getBodies() { return m_bodies; }
    const RigidBodyPtrSetVector& getBodies() const { return m_bodies; }
 
    WirePtrSetVector& getWires() { return m_wires; }
    const WirePtrSetVector& getWires() const { return m_wires; }
 
    const WireNodeRefVector& getUserWireNodes() const { return m_userWireNodes; }
 
  protected:
 
    using agxSDK::AssemblyVisitor::visit;
 
    virtual void visit(agx::RigidBody* body)
    {
      // Ignore powerline bodies
      if (!body->isPowerlineBody())
        m_bodies.insert(body);
    }
 
    virtual void visit(agxSDK::Assembly* assembly)
    {
      assembly->traverse(this);
    }
 
    // Visit "wires"
    virtual void visit(agxSDK::EventListener* listener)
    {
      if ( listener == nullptr )
        return;
 
      auto wire = listener->asSafe<agxWire::Wire>();
      if (wire == nullptr || m_wires.contains( wire ) || wire->getConstraint() == nullptr)
        return;
 
      const auto constraint = wire->getConstraint();
      for (auto it = constraint->getBeginIterator(); it != constraint->getEndIterator(); ++it) {
        auto rb = (*it)->getRigidBody();
        if ( agxWire::Wire::isLumpedNode( rb ) )
          m_bodies.insert( rb );
        else
          m_userWireNodes.push_back( *it );
      }
 
      m_wires.insert(wire);
    }
 
    virtual void visit(const agx::RigidBody*body) const
    {
      const_cast<CollectBodiesAndWiresVisitor *>(this)->visit(body);
    }
 
    virtual void visit(const agxSDK::Assembly* assembly)const
    {
      const_cast<CollectBodiesAndWiresVisitor *>(this)->visit(assembly);
    }
 
    virtual void visit(const agxSDK::EventListener*listener) const
    {
      const_cast<CollectBodiesAndWiresVisitor *>(this)->visit(listener);
    }
 
    RigidBodyPtrSetVector m_bodies;
    WirePtrSetVector m_wires;
    WireNodeRefVector m_userWireNodes;
  };
}
 
#endif