DynamicsSystem.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 <agx/agx.h>
 
#include <agx/Vec3.h>
#include <agx/Component.h>
#include <agx/Constraint.h>
#include <agx/TimeGovernor.h>
#include <agx/SymmetricPair.h>
#include <agx/agx_hash_types.h>
#include <agx/Task.h>
#include <agx/Solver.h>
#include <agx/ObserverFrame.h>
 
namespace agxCollide
{
  class Space;
}
 
namespace agxSDK
{
  class Simulation;
}
 
namespace agx
{
  typedef agx::SetVector<ConstraintRef> ConstraintRefSetVector;
  typedef agx::SetVector<InteractionRef> InteractionRefSetVector;
  typedef agx::SetVector<InteractionRef> StrongInteractionRefSetVector;
  typedef agx::SetVector<RigidBody*> RigidBodyPtrSetVector;
 
 
  // forward declarations
  class ConstraintImplementation;
  class DynamicsSystem;
  class IndexLambdaKernel;
 
  class AGXPHYSICS_EXPORT DynamicsSystem : public Component
  {
    public:
      static agx::Model* ClassModel();
 
    public:
      DynamicsSystem();
 
      DynamicsSystem( agx::Device* device );
 
      bool add( agx::RigidBody* rigidBody );
 
      bool remove( agx::RigidBody* rigidBody );
 
      bool add( agx::ObserverFrame* observerFrame );
 
      bool remove( agx::ObserverFrame* observerFrame );
 
      bool add( agx::Interaction* interaction );
 
      bool remove( agx::Interaction* interaction );
 
      bool add( agx::Constraint* constraint );
 
      bool remove( agx::Constraint* constraint );
 
      RigidBody* getRigidBody( const Name& name );
 
      const RigidBody* getRigidBody(const Name& name) const;
 
      Constraint* getConstraint( const Name& name);
 
      const Constraint* getConstraint( const Name& name ) const;
 
      ObserverFrame* getObserverFrame(const Name& name);
 
      const ObserverFrame* getObserverFrame(const Name& name) const;
 
      agx::RigidBody* getRigidBody( const agx::Uuid& uuid ) ;
 
      const agx::RigidBody* getRigidBody( const agx::Uuid& uuid ) const;
 
      const agx::Constraint* getConstraint( const agx::Uuid& uuid ) const;
 
      agx::Constraint* getConstraint( const agx::Uuid& uuid );
 
      const agx::ObserverFrame* getObserverFrame(const agx::Uuid& uuid) const;
 
      agx::ObserverFrame* getObserverFrame(const agx::Uuid& uuid);
 
      void setTimeGovernor( agx::TimeGovernor* tg );
 
      agx::TimeGovernor* getTimeGovernor() ;
 
      const agx::TimeGovernor* getTimeGovernor() const;
 
      void setGeometryContacts( const agxCollide::GeometryContactPtrVector* contacts );
 
      const agxCollide::GeometryContactPtrVector* getGeometryContacts() const;
 
 
      void stepForward();
 
      agx::Vec3 getLinearMomentum() const;
 
      agx::Vec3 getAngularMomentum() const;
 
      const agx::RigidBodyRefVector& getRigidBodies() const;
 
      agx::RigidBodyRefVector& getRigidBodies();
 
      const agx::ConstraintRefSetVector& getConstraints() const;
 
      agx::ConstraintRefSetVector& getConstraints();
 
      const ObserverFrameRefSetVector& getObserverFrames() const;
 
      ObserverFrameRefSetVector& getObserverFrames();
 
      agx::RigidBodyPtrSetVector& getEnabledRigidBodies();
 
      const agx::RigidBodyPtrSetVector& getEnabledRigidBodies() const;
 
      const agx::InteractionRefSetVector& getInteractions() const;
 
      const agx::StrongInteractionRefSetVector& getStrongInteractions() const;
 
      agx::Solver* getSolver();
 
      const agx::Solver* getSolver() const;
 
 
      void enableSolverDataExtraction(const agx::String& filename, const agx::String& solverDataGroup);
 
      void disableSolverDataExtraction();
 
      bool getEnableSolverDataExtraction() const;
 
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
      
      agxData::EntityStorage* getRigidBodyStorage();
 
      void _setGravityTask( agx::Task* task );
 
      agx::TaskGroup* getUpdateTask();
 
      agx::Index getInstanceId(const agx::Uuid& uuid) const;
 
      DOXYGEN_END_INTERNAL_BLOCK()
 
 
      void setEnableContactWarmstarting( bool enable );
 
      bool getEnableContactWarmstarting() const;
 
      DOXYGEN_START_INTERNAL_BLOCK()
      agx::IndexLambdaKernel* getIndexLambdaKernel() const;
      DOXYGEN_END_INTERNAL_BLOCK()
 
    protected:
 
      virtual ~DynamicsSystem();
 
    private:
 
      void updateFrames();
 
      void createUpdateTask();
 
      void setSimulation(agxSDK::Simulation* simulation);
 
      class SolveTask;
      friend class RigidBody;
      friend class agxSDK::Simulation;
 
      Task* createIntegratePositionsTask();
      Task* createUpdateFramesTask();
      Task* createSynchronizeGeometriesTask();
      Task* createMergedBodyPostIntegrateTask();
      Task* createPostIntegrateCallbacksTask();
 
      virtual void setContext(Object* context) override;
      void updateGravity();
      void init();
      void commitRemovedBodies();
      void reset();
      void disableBody( RigidBody* body );
      void enableBody( RigidBody* body );
 
      void updateInteractionForces();
 
      void startUpdateTimer(agx::Task* task);
      void stopUpdateTimerAndReport(agx::Task* task);
      void recordPlaybackStatistics();
 
      agxData::EntityStorageRef m_rigidBodyStorage;
      TaskRef m_updateWorldMassAndInertiaTask;
      TaskRef m_integratePositionsTask;
      TaskRef m_gravityTask;
 
    private:
      RigidBodyPtrSetVector m_enabledBodies;
      RigidBodyRefSetVector m_removedBodies;
 
      RigidBodyRefVector m_rigidBodies;
 
      ConstraintRefSetVector m_constraints;
      InteractionRefSetVector m_interactions;
      StrongInteractionRefSetVector m_strongInteractions;
 
      ObserverFrameRefSetVector m_observerFrames;
 
      ref_ptr<TimeGovernor> m_timeGovernor;
 
      const agxCollide::GeometryContactPtrVector* m_geometryContacts;
 
      int m_garbageCollectionCounter;
 
      TaskGroupRef m_updateTask;
      agxSDK::Simulation* m_simulation;
      agx::Timer m_updateTimer;
      agx::Task::ExecutionEvent::CallbackType m_startUpdateTimerCallback;
      agx::Task::ExecutionEvent::CallbackType m_stopUpdateTimerAndReportCallback;
 
      SolverRef m_solver;
      bool m_useSSE;
 
      LambdaKernelRef m_indexLambdaKernel;
  };
 
  typedef ref_ptr<DynamicsSystem> DynamicsSystemRef;
 
 
  //-------------------------------------------------------------------------
  // inline code
 
  inline RigidBodyPtrSetVector& DynamicsSystem::getEnabledRigidBodies()
  {
    return m_enabledBodies;
  }
 
  inline const RigidBodyPtrSetVector& DynamicsSystem::getEnabledRigidBodies() const
  {
    return m_enabledBodies;
  }
 
  inline void DynamicsSystem::setGeometryContacts( const agxCollide::GeometryContactPtrVector* contacts )
  {
    m_geometryContacts = contacts;
  }
 
  inline const agxCollide::GeometryContactPtrVector* DynamicsSystem::getGeometryContacts() const
  {
    return m_geometryContacts;
  }
 
  inline Solver* DynamicsSystem::getSolver() { return m_solver; }
  inline const Solver* DynamicsSystem::getSolver() const { return m_solver; }
 
 
} //namespace agx