Assembly.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/agx.h>
#include <agx/RigidBody.h>
#include <agx/MergedBody.h>
#include <agxCollide/agxCollide.h>
#include <agxSDK/agxSDK.h>
 
#include <agx/Frame.h>
#include <agxSDK/EventListener.h>
#include <agx/Constraint.h>
#include <agxCollide/Geometry.h>
#include <agx/ObserverFrame.h>
#include <agx/ParticleSystem.h>
#include <agxStream/Serializable.h>
#include <agx/SetVector.h>
#include <agx/DynamicsSystem.h>
#include <agxSDK/TerrainInstance.h>
#include <agxSDK/TerrainToolInstance.h>
 
namespace agxSDK
{
  typedef agx::SetVector< agx::ref_ptr<agxSDK::Assembly> > AssemblyRefSetVector;
 
  class AssemblyVisitor;
 
  AGX_DECLARE_POINTER_TYPES( Assembly );
  AGX_DECLARE_VECTOR_TYPES(Assembly);
  class AGXPHYSICS_EXPORT Assembly : public virtual agx::Referenced, public virtual agxStream::Serializable
  {
  public:
    Assembly();
 
    bool add(agx::Constraint* constraint);
 
    bool remove(agx::Constraint* constraint);
 
    bool add(agx::Interaction* interaction);
 
    bool remove(agx::Interaction* interaction);
 
    bool add(agxSDK::EventListener* listener);
 
    bool remove(EventListener* listener);
 
    bool add(agx::RigidBody* body);
 
    bool remove(agx::RigidBody* body, bool removeAssociatedGeometries = false, bool resetParentFrame=true);
 
    bool add(agxCollide::Geometry* geometry);
 
    bool remove(agxCollide::Geometry* geometry, bool resetParentFrame = true);
 
    bool add(Assembly* assembly);
 
    bool remove(Assembly* assembly, bool resetParentFrame=true);
 
    bool add(agx::ContactMaterial* contactMaterial);
 
    bool remove(agx::ContactMaterial* contactMaterial);
 
    bool add(agx::Emitter* emitter);
 
    bool remove(agx::Emitter* emitter);
 
    bool add(agx::ObserverFrame* observerFrame);
 
    bool remove(agx::ObserverFrame* observerFrame, bool resetParentFrame=true);
 
    bool add(agx::MergedBody* mergedBody);
 
    bool remove(agx::MergedBody *mergedBody);
 
    bool add(agxSDK::TerrainInstance* terrainInstance);
 
    bool remove(agxSDK::TerrainInstance* terrainInstance);
 
    bool add(agxSDK::TerrainToolInstance* toolInstance);
 
    bool remove(agxSDK::TerrainToolInstance* toolInstance);
 
    bool add(agxStream::Serializable* object);
 
 
 
    agx::RigidBody* getRigidBody(const agx::Name& name, bool recursive = true);
 
    const agx::RigidBody* getRigidBody(const agx::Name& name, bool recursive = true) const;
 
    agx::RigidBody* getRigidBody(const agx::Uuid& uuid, bool recursive = true);
 
    const agx::RigidBody* getRigidBody(const agx::Uuid& uuid, bool recursive = true) const;
 
    const agx::Constraint* getConstraint(const agx::Uuid& uuid, bool recursive = true) const;
 
    agx::Constraint* getConstraint(const agx::Uuid& uuid, bool recursive = true);
 
    const agx::Constraint* getConstraint(const agx::Name& name, bool recursive = true) const;
 
    agx::Constraint* getConstraint(const agx::Name& name, bool recursive = true);
 
    const agxSDK::Assembly* getAssembly(const agx::Name& name, bool recursive = true) const;
 
    agxSDK::Assembly* getAssembly(const agx::Name& name, bool recursive = true);
 
    const agxSDK::Assembly* getAssembly(const agx::Uuid& uuid, bool recursive = true) const;
 
    agxSDK::Assembly* getAssembly(const agx::Uuid& uuid, bool recursive = true);
 
    template < typename T >
    T* getConstraint(const agx::Name& name, bool recursive = true);
 
    template < typename T >
    const T* getConstraint(const agx::Name& name, bool recursive = true) const;
 
    const agxCollide::Geometry* getGeometry(const agx::Name& name, bool recursive = true) const;
 
    agxCollide::Geometry* getGeometry(const agx::Name& name, bool recursive = true);
 
    const agxCollide::Geometry* getGeometry(const agx::Uuid& uuid, bool recursive = true) const;
 
    agxCollide::Geometry* getGeometry(const agx::Uuid& uuid, bool recursive = true);
 
 
    const agx::ObserverFrame* getObserverFrame(const agx::Name& name, bool recursive = true) const;
 
    agx::ObserverFrame* getObserverFrame(const agx::Name& name, bool recursive = true);
 
    const agx::ObserverFrame* getObserverFrame(const agx::Uuid& uuid, bool recursive = true) const;
 
    agx::ObserverFrame* getObserverFrame(const agx::Uuid& uuid, bool recursive = true);
 
    const agx::MergedBody* getMergedBody (const agx::Uuid& uuid, bool recursive = true) const;
 
    agx::MergedBody* getMergedBody(const agx::Uuid& uuid, bool recursive = true);
 
 
    const agxSDK::TerrainInstance* getTerrainInstance(const agx::Uuid& uuid, bool recursive = true) const;
 
    agxSDK::TerrainInstance* getTerrainInstance(const agx::Uuid& uuid, bool recursive = true);
 
    const agxSDK::TerrainToolInstance* getTerrainToolInstance(const agx::Uuid& uuid, bool recursive = true) const;
 
    agxSDK::TerrainToolInstance* getTerrainToolInstance(const agx::Uuid& uuid, bool recursive = true);
 
 
 
    virtual void traverse(AssemblyVisitor* visitor);
    virtual void traverse(const AssemblyVisitor* visitor) const;
 
    const agx::RigidBodyRefSetVector& getRigidBodies() const;
 
    /*
    \param result - A Vector with all the RigidBodies found in this and any sub-assemblies
    \param recursive - If true, RigidBodies in sub-assemblies will be included
    \return Number of elements in the collected results.
    */
    size_t collect(agx::RigidBodyRefVector& result, bool recursive = true);
 
    const agxCollide::GeometryRefSetVector& getGeometries() const;
 
    /*
    \param result - A Vector with all the Geometries found in this and any sub-assemblies
    \param recursive - If true, Geometries in sub-assemblies will be included
    \return Number of elements in the collected results.
    */
    size_t collect(agxCollide::GeometryRefVector& result, bool recursive = true);
 
    const EventListenerRefSetVector& getEventListeners() const;
 
    /*
    \param result - A Vector with all the EventListeners found in this and any sub-assemblies
    \param recursive - If true, EventListeners in sub-assemblies will be included
    \return Number of elements in the collected results.
    */
    size_t collect(agxSDK::EventListenerRefVector& result, bool recursive = true);
 
    const AssemblyRefSetVector& getAssemblies() const;
 
    /*
    \param result - A Vector with all the Assemblies found in this and any sub-assemblies
    \param recursive - If true, Assemblies in sub-assemblies will be included
    \return Number of elements in the collected results.
    */
    size_t collect(agxSDK::AssemblyRefVector& result, bool recursive = true);
 
    const agx::ParticleSystemRefSetVector& getParticleSystems() const;
 
    /*
    \param result - A Vector with all the Particle systems found in this and any sub-assemblies
    \param recursive - If true, Particle systems in sub-assemblies will be included
    \return Number of elements in the collected results.
    */
    size_t collect(agx::ParticleSystemRefVector& result, bool recursive = true);
 
    const agx::EmitterRefSetVector& getEmitters() const;
 
    /*
    \param result - A Vector with all the Emitters found in this and any sub-assemblies
    \param recursive - If true, Emitters in sub-assemblies will be included
    \return Number of elements in the collected results.
    */
    size_t collect(agx::EmitterRefVector & result, bool recursive = true);
 
 
    const agx::ConstraintRefSetVector& getConstraints() const;
 
    size_t collect(agx::ConstraintRefVector& result, bool recursive = true);
 
    const agx::InteractionRefSetVector& getInteractions() const;
 
    size_t collect(agx::InteractionRefVector& result, bool recursive = true);
 
    const agx::ObserverFrameRefSetVector& getObserverFrames() const;
 
    size_t collect(agx::ObserverFrameRefVector& result, bool recursive = true);
 
    const agx::MergedBodyRefSetVector& getMergedBodies() const;
 
    size_t collect(agx::MergedBodyRefVector& result, bool recursive = true);
 
    const agxSDK::TerrainInstanceRefSetVector& getTerrainInstances() const;
 
    size_t collect(agxSDK::TerrainInstanceRefVector& result, bool recursive = true);
 
    const agxSDK::TerrainToolInstanceRefSetVector& getTerrainToolInstances() const;
 
    size_t collect(agxSDK::TerrainToolInstanceRefVector& result, bool recursive=true);
 
    virtual agx::Frame* getFrame();
    virtual const agx::Frame* getFrame() const;
 
    Assembly* getParent();
 
    const Assembly* getParent() const;
 
    void setTransform( const agx::AffineMatrix4x4& matrix );
 
    const agx::AffineMatrix4x4& getLocalTransform() const;
 
    void setLocalTransform( const agx::AffineMatrix4x4& matrix );
 
    agx::Vec3 getLocalPosition() const;
 
    void setLocalPosition( const agx::Vec3& p );
 
    void setLocalPosition( agx::Real x, agx::Real y, agx::Real z );
 
    void setRotation( const agx::Quat& q );
 
    void setRotation( const agx::EulerAngles& e);
 
    void setRotation( const agx::OrthoMatrix3x3& m );
 
    agx::Quat getLocalRotation() const;
 
    void setLocalRotation( const agx::Quat& q );
 
    void setLocalRotation( const agx::EulerAngles& e );
 
    agx::Frame* getParentFrame();
 
    const agx::Frame* getParentFrame() const;
 
    bool setParentFrame( agx::Frame* frame );
 
    void setPosition( const agx::Vec3& p );
 
    void setPosition( agx::Real x, agx::Real y, agx::Real z );
 
    AGX_ADD_FRAME_TRANSFORM_INTERFACE()
 
    
    virtual void addNotification(agxSDK::Simulation*) {}
 
    virtual void removeNotification(agxSDK::Simulation*) {}
 
    virtual void addNotification(Assembly*) {}
 
    virtual void removeNotification(Assembly*) { }
 
    agxSDK::Simulation* getSimulation();
 
    const agxSDK::Simulation* getSimulation() const;
 
    virtual void setVelocity(const agx::Vec3& velocity);
 
    virtual void setAngularVelocity(const agx::Vec3& velocity);
 
    enum Type {
      ASSEMBLY,  
      COLLECTION 
    };
 
    Type getType() const;
 
    void setName(const agx::Name& name);
 
    agx::Name getName() const;
 
    agx::Constraint1DOF* getConstraint1DOF(const agx::Name& name, bool recursive=true) { return this->getConstraint<agx::Constraint1DOF>(name, recursive); }
    agx::Constraint2DOF* getConstraint2DOF(const agx::Name& name, bool recursive=true) { return this->getConstraint<agx::Constraint2DOF>(name, recursive); }
 
    static Assembly* asAssembly(agxStream::Serializable *obj) { return dynamic_cast<Assembly *>(obj); }
 
    bool transfer(agxSDK::Assembly* target);
 
    bool reset(bool resetParentFrame = true);
 
    bool empty() const;
 
  public:
    AGXSTREAM_DECLARE_SERIALIZABLE(agxSDK::Assembly);
 
  protected:
 
 
    bool addParticleSystem(agx::ParticleSystem* particleSystem);
 
    bool removeParticleSystem(agx::ParticleSystem* particleSystem);
 
 
#if !defined(SWIG)
    Assembly(Type type);
#endif
 
    virtual ~Assembly();
    friend class Simulation;
 
    void addToSimulation(Simulation* simulation);
    void removeFromSimulation(Simulation* simulation);
 
  private:
 
    agx::FrameRef m_frame;
 
    agxCollide::GeometryRefSetVector m_geometries;
    agx::RigidBodyRefSetVector m_bodies;
    agx::ConstraintRefSetVector m_constraints;
    agx::EmitterRefSetVector m_emitters;
    EventListenerRefSetVector m_listeners;
    agxSDK::Simulation* m_simulation;
    agx::InteractionRefSetVector m_interactions;
 
    agx::ContactMaterialRefSetVector m_contactMaterials;
    agx::ParticleSystemRefSetVector m_particleSystems;
 
    AssemblyRefSetVector m_assemblies;
    AssemblyObserver m_parent;
 
    agx::ObserverFrameRefSetVector m_observers;
    agx::MergedBodyRefSetVector m_mergedBodies;
    agxSDK::TerrainInstanceRefSetVector m_terrains;
    agxSDK::TerrainToolInstanceRefSetVector m_terrainTools;
 
    Type m_type;
    agx::Name m_name;
  };
 
 
  inline agx::Frame* Assembly::getFrame()
  {
    return m_frame.get();
  }
 
  inline const agx::Frame* Assembly::getFrame() const
  {
    return m_frame.get();
  }
 
  class AGXPHYSICS_EXPORT AssemblyVisitor
  {
  public:
 
    bool succeed() const;
 
    // Constructor
    AssemblyVisitor();
    virtual ~AssemblyVisitor();
 
  protected:
 
    friend class Assembly;
    virtual void visit(agx::Constraint*) {}
    virtual void visit(agx::Interaction*) {}
    virtual void visit(agx::RigidBody*) {}
    virtual void visit(agxCollide::Geometry*) {}
    virtual void visit(Assembly*);
    virtual void visit(EventListener*) {}
    virtual void visit(agx::ContactMaterial*) {}
    virtual void visit(agx::ParticleSystem*) {}
    virtual void visit(agx::Emitter*) {}
    virtual void visit(agx::ObserverFrame*) {}
    virtual void visit(agx::MergedBody*) {}
    virtual void visit(agxSDK::TerrainInstance*) {}
    virtual void visit(agxSDK::TerrainToolInstance*) {}
 
    virtual void visit(const agx::Constraint*) const {}
    virtual void visit(const agx::Interaction*) const {}
    virtual void visit(const agx::RigidBody*) const {}
    virtual void visit(const agxCollide::Geometry*) const {}
    virtual void visit(const Assembly*)const;
    virtual void visit(const EventListener*) const {}
    virtual void visit(const agx::ContactMaterial*) const {}
    virtual void visit(const agx::ParticleSystem*) const {}
    virtual void visit(const agx::Emitter*) const {}
    virtual void visit(const agx::ObserverFrame*) const {}
    virtual void visit(const agx::MergedBody*) const {}
    virtual void visit(const agxSDK::TerrainInstance*) const {}
    virtual void visit(const agxSDK::TerrainToolInstance*) const {}
 
    void setSucceed(bool flag) {
      m_succeed = flag;
    }
 
    bool m_succeed;
  };
 
 
 
  /* Implementation */
 
 
  template< typename T >
  T* Assembly::getConstraint(const agx::Name& name, bool recursive)
  {
    return dynamic_cast< T* >(this->getConstraint(name, recursive));
  }
 
  template< typename T >
  const T* Assembly::getConstraint(const agx::Name& name, bool recursive) const
  {
    return dynamic_cast< const T* >(this->getConstraint(name, recursive));
  }
 
 
}