Simulation.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/config/AGX_USE_WEBSOCKETS.h>
#include <agx/config/AGX_USE_WEB_DEBUGGER.h>
#include <agxSDK/agxSDK.h>
#include <agxSDK/SimulationProxy.h>
#include <agxSDK/SimulationSerializer.h>
#include <agxSDK/EventManager.h>
#include <agxSDK/MaterialManager.h>
#include <agxSDK/Assembly.h>
#include <agxSDK/StatisticsEntries.h>
#include <agxSDK/SimulationStatisticsListener.h>
#include <agxSDK/RemoteDebugRenderProxy.h>
#include <agx/DynamicsSystem.h>
#include <agx/TimeStamp.h>
#include <agx/HashTable.h>
#include <agx/Component.h>
#include <agx/GravityField.h>
#include <agx/Clock.h>
#include <agx/ParticleContactSensor.h>
#include <agxData/Frame.h>
 
#include <agxControl/ActionManager.h>
 
#include <agxCollide/Space.h>
 
#include <agxSDK/SimulationParameter.h>
 
#include <agxSDK/TerrainManager.h>
 
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning( disable : 4290 ) // C++ exception specification ignored except to indicate a function is not __declspec(nothrow)
#endif
 
namespace agx
{
  class Interaction;
  class ParticleSystem;
  class RigidBody;
  class MergedBody;
  class ParticleEmitter;
  class RigidBodyEmitter;
  class Journal;
  class RemoteSolver;
  class Solver;
  class ObserverFrame;
  class StabilityReport;
 
  class Hinge;
  class Prismatic;
  class DistanceJoint;
  class LockJoint;
  class BallJoint;
  class PlaneJoint;
  class AngularLockJoint;
  class CylindricalJoint;
  class UniversalJoint;
  class PrismaticUniversalJoint;
}
 
namespace agxCollide
{
  class Geometry;
}
 
namespace agxNet
{
  class RemoteDebugClient;
}
 
namespace agxRender
{
  class RenderManager;
}
 
namespace agxWire
{
  class Wire;
}
 
namespace agxModel
{
  class SurfaceVelocityConveyorBelt;
}
 
namespace agxPlot
{
  class System;
  class DataSeries;
}
 
namespace agxSDK
{
  class SimulationFrameReader;
  class SimulationFrameWriter;
  class EventListener;
  class SimulationFrameWriter;
  class GuiEventAdapterImplementation;
  class PickHandler;
  class MergeSplitHandler;
  class TerrainInstance;
  class TerrainToolInstance;
  class EnergyManager;
  class ISensorEnvironment;
 
  typedef agx::HashVector<agxSDK::Assembly*, agxSDK::AssemblyRef> AssemblyHash;
 
  AGX_DECLARE_POINTER_TYPES(Simulation);
  class CALLABLE AGXPHYSICS_EXPORT Simulation : public agx::Component
  {
    public:
      typedef agx::Event2<Simulation*, agxCollide::Geometry*> GeometryEvent;
      typedef agx::Event2<Simulation*, agx::RigidBody*> RigidBodyEvent;
      typedef agx::Event2<Simulation*, agx::Constraint*> ConstraintEvent;
      typedef agx::Event2<Simulation*, agx::Material*> MaterialEvent;
      typedef agx::Event2<Simulation*, agx::ContactMaterial*> ContactMaterialEvent;
      typedef agx::Event2<Simulation*, agx::Journal*> JournalAttachEvent;
 
      GeometryEvent addGeometryEvent;
      GeometryEvent removeGeometryEvent;
 
      RigidBodyEvent addRigidBodyEvent;
      RigidBodyEvent removeRigidBodyEvent;
 
      ConstraintEvent addConstraintEvent;
      ConstraintEvent removeConstraintEvent;
 
      MaterialEvent addMaterialEvent;
      MaterialEvent removeMaterialEvent;
 
      ContactMaterialEvent addContactMaterialEvent;
      ContactMaterialEvent removeContactMaterialEvent;
 
      JournalAttachEvent journalAttachedEvent;
 
    public:
      static agxSDK::SimulationProxyRef createDefaultProxy( agxSDK::Simulation* simulation );
 
    public:
      Simulation();
 
      bool add( agx::Material* material );
 
      bool add( agx::ContactMaterial* material );
 
      bool remove( agx::ContactMaterial* material );
 
      const agx::Material* getMaterial(const agx::Name& materialName) const;
 
      agx::Material* getMaterial(const agx::Name& materialName);
 
      agx::Material* getMaterial(const agx::Uuid& uuid);
 
      MaterialManager* getMaterialManager();
 
      const MaterialManager* getMaterialManager() const;
 
      bool remove( agx::Material* material );
 
      bool add( agxCollide::Geometry* geometry );
 
      bool remove( agxCollide::Geometry* geometry );
 
      bool add( agx::RigidBody* body, bool addGeometries = true );
 
      bool remove( agx::RigidBody* body, bool removeGeometries = true );
 
      bool add( agx::MergedBody* mergedBody );
 
      bool remove( agx::MergedBody* mergedBody );
 
      bool add( agx::Constraint* constraint );
 
      bool remove( agx::Constraint* constraint );
 
      bool add( agx::Interaction* interaction );
 
      bool remove( agx::Interaction* interaction );
 
      bool add( agxSDK::Assembly* assembly, bool addAllEntries = true );
 
      bool remove( agxSDK::Assembly* assembly, bool removeAllEntries = true );
 
      bool add( agx::Component* subComponent );
 
      bool remove( agx::Component* subComponent );
 
      bool add(agx::ObserverFrame* observerFrame);
 
      bool remove(agx::ObserverFrame* observerFrame);
 
      bool contains( const agx::Component* object ) const;
 
      bool contains(const agxSDK::TerrainInstance* terrain) const;
 
      bool contains(const agxSDK::TerrainToolInstance* toolInstance) const;
 
      bool add( agxControl::Action* action );
 
      bool remove( agxControl::Action* action );
 
      bool add( agxControl::Operation* operation );
 
      bool remove( agxControl::Operation* operation );
 
      bool add( agx::ParticleSystem* particleSystem );
 
      bool remove( agx::ParticleSystem* particleSystem);
 
      bool add( agx::Emitter* emitter, bool addGeometries=true);
 
      bool remove(agx::Emitter* emitter, bool removeGeometries=true);
 
      bool add( agx::ParticleContactSensor* sensor );
 
      bool remove( agx::ParticleContactSensor* sensor );
 
      agx::ParticleEmitterRefVector getParticleEmitters();
 
      agx::EmitterRefVector getEmitters();
 
      agx::ParticleSystemRefVector& getParticleSystems();
 
      const agx::ParticleSystemRefVector& getParticleSystems() const;
 
      agx::ParticleSystem* getParticleSystem() const;
 
      bool add( agxSDK::TerrainInstance* terrain );
 
      bool remove( agxSDK::TerrainInstance* terrain );
 
      bool add( agxSDK::TerrainToolInstance* toolInstance );
 
      bool remove( agxSDK::TerrainToolInstance* toolInstance );
 
      bool setUniformGravity( const agx::Vec3& g );
 
      agx::Vec3 getUniformGravity() const;
 
      void setGravityField( agx::GravityField* gravityField );
 
      agx::GravityField* getGravityField();
 
      const agx::GravityField* getGravityField() const;
 
      void setMainWorkThread(agx::Thread* thread);
 
      agx::RigidBody* getRigidBody( const agx::Name& name );
 
      const agx::RigidBody* getRigidBody( const agx::Name& name ) const;
 
      agx::RigidBody* getRigidBody( const agx::Uuid& uuid ) ;
 
      const agx::RigidBody* getRigidBody( const agx::Uuid& uuid ) const;
 
      agx::MergedBody* getMergedBody(const agx::Name& name);
 
      const agx::MergedBody* getMergedBody(const agx::Name& name) const;
 
      agx::MergedBody* getMergedBody(const agx::Uuid& uuid);
 
      const agx::MergedBody* getMergedBody(const agx::Uuid& uuid) const;
 
      const agx::Constraint* getConstraint( const agx::Uuid& uuid ) const;
 
      agx::Constraint* getConstraint( const agx::Uuid& uuid );
 
      const agx::Constraint* getConstraint(const agx::Name& name) const;
 
      agx::Constraint* getConstraint(const agx::Name& name);
 
      const agxSDK::Assembly* getAssembly(const agx::Name& name) const;
 
      agxSDK::Assembly* getAssembly(const agx::Name& name);
 
      const agxSDK::Assembly* getAssembly(const agx::Uuid& uuid) const;
 
      agxSDK::Assembly* getAssembly(const agx::Uuid& uuid);
 
      const agx::Emitter* getEmitter(const agx::Uuid& uuid) const;
 
      agx::Emitter* getEmitter(const agx::Uuid& uuid);
 
      agx::Emitter* getEmitter(const agx::Name& name) const;
 
      agx::Emitter* getEmitter(const agx::Name& name);
 
      template < typename T >
      T* getConstraint(const agx::Uuid& uuid);
 
      template < typename T >
      const T* getConstraint(const agx::Uuid& uuid) const;
 
      template < typename T >
      T* getConstraint( const agx::Name& name );
 
      template < typename T >
      const T* getConstraint( const agx::Name& name ) const;
 
#define GETCONSTRAINT_TYPE(CLASS_NAME, TYPENAME)    \
      CLASS_NAME *get ## TYPENAME(const agx::Name& name); \
      CLASS_NAME *get ##TYPENAME(const agx::Uuid& uuid);
 
      GETCONSTRAINT_TYPE(agx::AngularLockJoint, AngularLockJoint)
      GETCONSTRAINT_TYPE(agx::BallJoint, BallJoint)
      GETCONSTRAINT_TYPE(agx::CylindricalJoint, CylindricalJoint)
      GETCONSTRAINT_TYPE(agx::DistanceJoint, DistanceJoint)
      GETCONSTRAINT_TYPE(agx::Hinge, Hinge)
      GETCONSTRAINT_TYPE(agx::LockJoint, LockJoint)
      GETCONSTRAINT_TYPE(agx::PlaneJoint, PlaneJoint)
      GETCONSTRAINT_TYPE(agx::Prismatic, Prismatic)
      GETCONSTRAINT_TYPE(agx::PrismaticUniversalJoint, PrismaticUniversalJoint)
      GETCONSTRAINT_TYPE(agx::UniversalJoint, UniversalJoint)
#undef GETCONSTRAINT_TYPE
 
      const agxCollide::Geometry* getGeometry(const agx::Name& name ) const;
 
      agxCollide::Geometry* getGeometry(const agx::Name& name );
 
      const agxCollide::Geometry* getGeometry( const agx::Uuid& uuid ) const;
 
      agxCollide::Geometry* getGeometry( const agx::Uuid& uuid );
 
      const agxSDK::EventListener* getEventListener(const agx::Name& name ) const;
 
      agxSDK::EventListener* getEventListener(const agx::Name& name );
 
      const agxSDK::EventListener* getEventListener(const agx::Uuid& uuid) const;
 
      agxSDK::EventListener* getEventListener(const agx::Uuid& uuid);
 
 
      const agxWire::Wire* getWire(const agx::Name& name) const;
 
      agxWire::Wire* getWire(const agx::Name& name);
 
      const agxWire::Wire* getWire(const agx::Uuid& uuid) const;
 
      agxWire::Wire* getWire(const agx::Uuid& uuid);
 
      agx::ObserverFrame* getObserver(const agx::Name& name);
 
      const agx::ObserverFrame* getObserver(const agx::Name& name) const;
 
      agx::ObserverFrame* getObserver(const agx::Uuid& uuid);
 
      const agx::ObserverFrame* getObserver(const agx::Uuid& uuid) const;
 
      agx::TimeStamp stepTo( agx::TimeStamp t );
 
      agx::Real getTimeStep() const;
 
      bool setTimeStep( agx::Real timeStep );
 
      agx::Clock* getClock();
 
      const agx::Clock* getClock() const;
 
      agx::Journal* getJournal();
 
      const agx::Journal* getJournal() const;
 
  #if AGX_USE_WEBSOCKETS()
      agx::RemoteSolver* getRemoteSolver();
 
      const agx::RemoteSolver* getRemoteSolver() const;
  #endif
 
      bool breakStepTo();
 
      agx::Real getTimeStamp() const;
 
      void setTimeStamp( agx::TimeStamp t );
 
      void stepForward();
 
      agxCollide::Space* getSpace();
 
      const agxCollide::Space* getSpace() const;
 
      agx::DynamicsSystem* getDynamicsSystem();
 
      const agx::DynamicsSystem* getDynamicsSystem() const;
 
      agxPlot::System* getPlotSystem() const;
 
      void setPlotSystem(agxPlot::System* plotSystem);
 
      void setSpace( agxCollide::Space* space );
 
      void setDynamicsSystem( agx::DynamicsSystem* system );
 
 
      bool removeEventListener( agxSDK::EventListener* listener );
 
      bool addEventListener( agxSDK::EventListener* listener, int priority = EventManager::DEFAULT_PRIORITY );
 
      bool add( agxSDK::EventListener* listener, int priority = EventManager::DEFAULT_PRIORITY );
 
      bool remove( agxSDK::EventListener* listener );
 
      bool triggerEvent( const GuiEvent& e );
 
      agxPlot::DataSeries* getTimeDataSeries() const;
 
#ifdef SWIG
      enum CleanupSelectionMask {
        STEP_LISTENERS = 0x1,                                 
        CONTACT_LISTENERS = 0x2,                              
        GUI_LISTENERS = 0x4,                                  
        LISTENERS = STEP_LISTENERS | CONTACT_LISTENERS | GUI_LISTENERS,  
        SYSTEM = 0x200,                                       
        SPACE = 0x400,                                        
        MATERIALS = 0x800,                                    
        ASSEMBLIES = 0x1000,                                  
        PARTICLE_SYSTEMS = 0x2000,                            
        CONTACT_DATA = 0x4000,                                
        CLEANUP_ALL = LISTENERS | SYSTEM | SPACE | MATERIALS | ASSEMBLIES | PARTICLE_SYSTEMS | CONTACT_DATA
      };
#else
      enum CleanupSelectionMask {
        STEP_LISTENERS = EventManager::STEP_LISTENERS,        
        CONTACT_LISTENERS = EventManager::CONTACT_LISTENERS,  
        GUI_LISTENERS = EventManager::GUI_LISTENERS,          
        LISTENERS = EventManager::LISTENERS,                  
        SYSTEM = 0x200,                                       
        SPACE = 0x400,                                        
        MATERIALS = 0x800,                                    
        ASSEMBLIES = 0x1000,                                  
        PARTICLE_SYSTEMS = 0x2000,                            
        CONTACT_DATA = 0x4000,                                
        PLOTSYSTEM = 0x8000,                                  
        CLEANUP_ALL = LISTENERS | SYSTEM | SPACE | MATERIALS | ASSEMBLIES | PARTICLE_SYSTEMS | CONTACT_DATA | PLOTSYSTEM
      };
#endif
 
      enum ReadSelectionMask {
        READ_NONE = 0x0,             
        READ_TIMESTEP = 0x1,         
        READ_TIMESTAMP = 0x2,        
        READ_GRAVITY = 0x4,          
        READ_SOLVER = 0x8,           
        READ_ALL = READ_TIMESTEP + READ_TIMESTAMP + READ_GRAVITY + READ_SOLVER,
        READ_DEFAULT = READ_TIMESTEP /* + READ_TIMESTAMP */ + READ_GRAVITY + READ_SOLVER // Not using READ_TIMESTAMP
      };
 
      void cleanup( agx::UInt selection = CLEANUP_ALL, bool fast=false );
 
      void setActionManagerTimeStamp(const agx::TimeStamp& time);
 
      agxControl::ActionManager* getActionManager();
 
      void clearContactData();
 
      agx::Solver* getSolver();
 
      const agx::Solver* getSolver() const;
 
      void setPreIntegratePositions( bool flag );
 
      bool getPreIntegratePositions() const;
 
      bool add( agxStream::Serializable* object );
 
      bool remove( agxStream::Serializable* object );
 
 
      agxSDK::PickHandler* getPickHandler();
 
      const agxSDK::PickHandler* getPickHandler() const;
 
      void setPickHandler( agxSDK::PickHandler* pickHandler );
 
      void setStatisticsPath( const agx::String& path );
 
      void setStatisticsInterval( agx::Real interval );
 
      void setEnableStatistics( bool enable );
 
      bool getEnableStatistics() const;
 
      void setEnableStatisticsRendering( bool enable );
 
      bool getEnableStatisticsRendering() const;
 
      void setProfilingFrequency(agx::Real frequency);
 
      agx::Real getProfilingFrequency() const;
 
      const AssemblyHash& getAssemblies() const;
 
      AssemblyPtrVector getAssemblyPtrVector() const;
 
      void getEventListeners( EventListenerPtrVector& eventListeners ) const;
 
      const agxCollide::GeometryRefVector& getGeometries() const;
 
      const agx::RigidBodyRefVector& getRigidBodies() const;
 
      agx::RigidBodyRefVector& getRigidBodies();
 
 
      const agx::ConstraintRefSetVector& getConstraints() const;
 
      agx::ConstraintRefSetVector& getConstraints();
 
      const agx::ObserverFrameRefSetVector& getObserverFrames() const;
 
      agx::ObserverFrameRefSetVector& getObserverFrames();
 
      agx::RigidBodyPtrSetVector& getEnabledRigidBodies();
 
      const agx::RigidBodyPtrSetVector& getEnabledRigidBodies() const;
 
      const agx::ObserverFrame* getObserverFrame(const agx::Uuid& uuid) const;
 
      agx::ObserverFrame* getObserverFrame(const agx::Uuid& uuid);
 
      agx::ObserverFrame* getObserverFrame(const agx::Name& name);
 
      const agx::ObserverFrame* getObserverFrame(const agx::Name& name) const;
 
 
      size_t write( const agx::String& filename ) const;
 
      size_t write( std::ostream& stream, bool binary ) const;
 
      size_t read( const agx::String& filename, agxSDK::Assembly* parent = nullptr, agx::UInt selection = READ_DEFAULT);
 
      size_t read( std::istream& stream, bool isBinary, agxSDK::Assembly* parent = nullptr, agx::UInt selection = READ_DEFAULT);
 
      bool restore(const agx::String& filename, agx::UInt selection = READ_DEFAULT);
      bool restore(std::istream& stream, bool isBinary, agx::UInt selection = READ_DEFAULT);
 
 
      bool addRestoreListener( agxStream::RestoreListener* listener );
 
      bool removeRestoreListener( agxStream::RestoreListener* listener );
 
      void store( agxStream::OutputArchive& archive ) const;
 
      void restore( agxStream::InputArchive& in,
                    agxSDK::Assembly* parent = nullptr,
                    agx::UInt selection = READ_DEFAULT,
                    bool replaceUsingCache = false );
 
      void setEnableRemoteDebugging( bool flag, agx::Int16 port = -1,
                                     bool useCompression = false,
                                     bool waitForSynchronization = true );
 
      bool getEnableRemoteDebugging() const;
 
      void setRemoteDebuggingTimeStep( agx::Real timeStep );
 
      agx::Real getRemoteDebuggingTimeStep() const;
 
      void setEnableWebDebugger(bool flag, agx::UInt16 port=9001);
 
      bool getEnableWebDebugger() const;
 
      #if AGX_USE_WEB_DEBUGGER()
 
      agxSDK::RemoteDebugRenderProxyFactory* getWebDebugger();
 
      const agxSDK::RemoteDebugRenderProxyFactory* getWebDebugger() const;
      #endif
 
      void setContactReductionBinResolution( agx::UInt8 binResolution );
 
      agx::UInt8 getContactReductionBinResolution() const;
 
      void setContactReductionThreshold(agx::UInt threshold);
 
      agx::UInt getContactReductionThreshold() const;
 
      agxSDK::MergeSplitHandler* getMergeSplitHandler() const;
 
      agxRender::RenderManager* getRenderManager();
 
      const agxRender::RenderManager* getRenderManager() const;
 
      void updateRenderManager();
 
      void updateStatisticsRenderData();
 
      void garbageCollect();
 
      bool add(agxSDK::SimulationParameter* parameter);
 
      bool remove(agxSDK::SimulationParameter* parameter);
 
      const agxSDK::SimulationParameterRefVector& getParameters() const;
 
      agxSDK::SimulationParameter* getParameter(const agx::Name& name);
 
      agxSDK::EnergyManager* getEnergyManager() const;
 
      void setSensorEnvironment( ISensorEnvironment* environment );
 
      ISensorEnvironment* getSensorEnvironment() const;
 
  public:
      // Internal, but public methods
 
      void sendSimulation();
 
      SimulationSerializer* getSerializer();
 
      const SimulationSerializer* getSerializer() const;
 
      void setSerializer( SimulationSerializer* serializer);
 
 
      void updateActionManager();
 
      agxSDK::SimulationProxy* getSimulationProxy() const;
 
      void commit( agxSDK::SimulationProxy* simulationProxy );
 
      void handleStabiltyReport( const agx::StabilityReport* stabilityReport );
 
      agx::TaskGroup* getUpdateTask();
 
      void renderComponents();
      void createRenderTask();
      agx::SolveModel* getSolveModel(const agx::Name& name);
 
      const agx::SolveModelRefVector& getSolveModels() const;
 
      #if AGX_USE_WEBSOCKETS()
        void setRemoteSolver(agx::RemoteSolver* remoteSolver);
      #endif
 
      Simulation( agx::Device* device );
 
      static Simulation* load(agx::TiXmlElement* eSimulation, agx::Device* device);
 
      static agx::Model* ClassModel();
 
      void setEnableSimulationStatisticsListener( bool flag );
 
      SimulationStatisticsListener* getSimulationStatisticsListener();
      const SimulationStatisticsListener* getSimulationStatisticsListener() const;
 
      void addSolveModel(agx::SolveModel* model);
      void removeSolveModel(agx::SolveModel* model);
      void loadSolveModels(const agx::String& path, bool clear = false);
 
      // For LUA only
      agx::Constraint1DOF* getConstraint1DOF(const agx::Name& name) { return this->getConstraint<agx::Constraint1DOF>(name); }
      agx::Constraint2DOF* getConstraint2DOF(const agx::Name& name) { return this->getConstraint<agx::Constraint2DOF>(name); }
 
      agx::UInt getNumMergedBodies() const;
 
      agx::MergedBody* getMergedBody( agx::UInt i ) const;
 
      agx::UInt getNumTerrains() const;
 
      agxSDK::TerrainInstance* getTerrain( agx::UInt i ) const;
 
      agxSDK::TerrainManager* getTerrainManager() const;
 
      void resetTaskTimers();
 
      void dumpTaskTimers(const agx::String& filePath = "BufferAllocations.xml");
 
      void dumpMemoryUsage(const agx::String& filePath = "TaskTimers.xml");
 
 
      bool allowCreateParticles() const;
 
      agx::Component *getHeader();
      void readStoragePermutations(agxStream::InputArchive& in, bool clearStorages = false);
      void writeStoragePermutations(agxStream::OutputArchive& archive) const;
 
      void writeStatisticsFiles(const agx::String& directoryPath = "Statistics", bool taskProfile = true, bool threadTimeline = true, const agx::Vector<agx::String>& timelineFormats = agx::Vector<agx::String>(), bool bufferAllocations = true);
 
      agxData::EntityStorage* getEmitterStorage();
 
      void setEnableClearRenderTemporaries(bool enable);
 
      bool getEnableClearRenderTemporaries() const;
 
      bool enableThreadTimeline(const agx::String& sessionName = "",
                                const agx::String& journalName = "Profiling.agxJournal");
 
      bool disableThreadTimeline(const agx::String& format = "chrome");
 
 
    protected:
      friend class agxNet::RemoteDebugClient;
      friend class GuiEventAdapterImplementation;
      friend class agx::DynamicsSystem;
      friend class agxSDK::SimulationFrameReader;
      friend class agxRender::RenderManager;
 
      virtual ~Simulation();
 
    private:
      using ReferencedRef = agx::ref_ptr<agx::Referenced>;
      using ConstReferencedRef = agx::ref_ptr<const agx::Referenced>;
 
    private:
      void addListener(EventListener *listener);
      void removeListener(EventListener *listener);
      bool hasListener(EventListener *listener);
 
    private:
      void init();
 
      void initConfiguration();
 
      void updateStatisticsEnable();
 
      void setEnableComputeAllConstraintForces(bool flag);
      bool getEnableComputeAllConstraintForces() const;
 
      void resetGraphStatistics();
 
      agx::Vec4 getSubsystemColor(agx::RigidBody* body);
 
      void setupStatisticsLogging();
 
      void updateConstraintForceData();
 
      void createUpdateTask();
 
      void generateContactMaterials();
      void preCollide();
      void prepareContacts();
      void triggerParticleContactSensors();
      void triggerPreStepEvents();
      void triggerPostStepEvents();
      void triggerLastStepEvents();
      void terrainPostUpdate();
      void stepSystem();
      void resetDirtyMaterials();
      void updateRemoteDebugger();
      void recordStatistics();
      void recordPlaybackStatistics();
      void recordParticleCount();
      void recordWarmStartingData();
      void printStatistics();
      void updateClock();
 
 
      void pruneContacts();
      void contactPointReduction();
      void updateSleepState();
      void triggerPreCollideStepEvent();
      void triggerSeparationContactEventListeners();
      void triggerContactEventListeners();
      void assignContactMaterials();
      void dumpThreadLogs(agx::Task *);
 
      void applyPreIntegrationSettings();
 
    private:
      friend class agx::Solver;
      void registerParticleSystemPointers();
      void unregisterParticleSystemPointers();
      void removeParticleSolverObjects( agx::ParticleSystem* particleSystem );
 
    private:
      class StatisticsWriter;
 
      friend class agx::Journal;
      friend class agxSDK::SimulationFrameWriter;
      #if AGX_USE_WEBSOCKETS()
        friend class agx::RemoteSolver;
      #endif
 
      void setJournal(agx::Journal* journal);
      void setHasJournal(bool flag);
      void preStoreSynchronization();
 
      StatisticsEntries m_statisticsEntry;
      StatisticsWriter* m_statWriter;
 
      typedef agx::HashTable<agxCollide::Geometry*, int> GeometryTable;
 
      AssemblyHash m_assemblies;
 
      agxCollide::SpaceRef m_space;
      agx::DynamicsSystemRef m_system;
 
      ReferencedRef m_plotSystem;
      ReferencedRef m_timeDataSeries;
 
      agx::ComponentRef m_header;
      bool m_stepToStarted;
 
      EventManagerRef m_eventManager;
      MaterialManagerRef m_materialManager;
 
      agxControl::ActionManagerRef m_actionManager;
      agx::TaskRef m_actionManagerTask;
 
      agx::observer_ptr< Referenced > m_pickHandler;
 
      SimulationSerializerRef m_serializationListener;
 
      agx::ParticleSystemRefVector m_particleSystems;
      agx::TaskGroupRef m_updateEmitters;
      agxData::EntityStorageRef m_emitterStorage;
 
      ReferencedRef m_controlledServer;
      ReferencedRef m_debugServer;
      agx::UInt8 m_contactReductionBinResolution;
      agx::UInt m_contactReductionThreshold;
      agx::ComponentRefVector m_subComponents;
      agx::Real m_remoteDebuggerTimeStep;
      agx::TimeStamp m_remoteDebuggerTimeStamp;
      agx::TaskGroupRef m_updateTask;
      agx::TaskRefVector m_preIntegrateTasks;
      bool m_preIntegrate;
      bool m_fastCleanup;
      bool m_allowCreateParticles;
 
      agx::Timer m_stepTimer;
      agx::Timer m_updateRenderManagerTimer;
      agx::ClockRef m_clock;
      agx::TaskRef m_renderTask;
      agx::GravityFieldRef m_gravityField;
 
      agx::SolveModelTable m_solveModelTable;
      agx::SolveModelRefVector m_solveModels;
 
      ReferencedRef m_renderManager;
      bool m_clearRenderTemporaries;
      agx::Thread* m_mainWorkThread;
      agxData::FrameRef m_journalLastWrittenFrame;
      agx::UInt32 m_journalAgxArchiveIdCounter;
 
      void* m_journal;
      bool m_hasJournal;
      void* m_remoteSolver;
 
      agx::ref_ptr<agx::Referenced> m_profilingJournal;
 
      agxData::EntityStorageRef m_constraintForcesStorage;
      bool m_enableComputeAllConstraintForces;
      bool m_inDestructor;
      SimulationProxyRef m_simulationProxy;  
      agx::ParticleContactSensorRefVector m_particleContactSensors;
 
      typedef agx::HashTable<agxCollide::Geometry*, agx::ParticleContactSensorPtrVector*> ParticleContactSensorTable;
      ParticleContactSensorTable m_particleContactSensorTable;
 
      typedef agx::HashTable<agxStream::RestoreListener*, agxStream::RestoreListenerRef> RestoreListenerHash;
      RestoreListenerHash m_restoreListeners;
      agxSDK::SimulationStatisticsListenerRef m_simulationStatisticsListener;
      agx::Real m_profilingFrequency;
 
      using StabilityReportContainer = agx::Vector<ConstReferencedRef>;
      StabilityReportContainer m_stabilityReports;
 
      using MergedBodyContainerType = ReferencedRef;
      using MergedBodiesContainer = agx::Vector<MergedBodyContainerType>;
      MergedBodiesContainer m_mergedBodies;
 
      using MergeSplitHandlerPointer = ReferencedRef;
      MergeSplitHandlerPointer m_mergeSplitHandler;
 
      using LinkedStructureContainerType = ReferencedRef;
      using LinkedStructureContainer = agx::Vector<LinkedStructureContainerType>;
      LinkedStructureContainer m_linkedStructures;
 
      bool m_disableGeometryAutoAdd;
      agxSDK::SimulationParameterRefVector m_simulationParameters;
 
      agx::RangeJobVector    m_postSolveConstraintForceJobs;
      agx::ParallelTaskRef   m_postSolveConstraintForceTask;
 
      ReferencedRef m_energyManager;
      ReferencedRef m_sensorEnvironment;
      agxSDK::TerrainManagerRef m_terrainManager;
 
      #if AGX_USE_WEB_DEBUGGER()
      agx::ref_ptr<agxSDK::RemoteDebugRenderProxyFactory> m_webDebugger;
      #endif
  };
 
  /* Implementation */
  AGX_FORCE_INLINE agx::Real Simulation::getTimeStamp() const
  {
    return m_clock->getTime();
  }
 
  AGX_FORCE_INLINE agxCollide::Space* Simulation::getSpace()
  {
    return m_space.get();
  }
 
  AGX_FORCE_INLINE const agxCollide::Space* Simulation::getSpace() const
  {
    return m_space.get();
  }
 
  AGX_FORCE_INLINE const agx::DynamicsSystem* Simulation::getDynamicsSystem() const
  {
    return m_system.get();
  }
 
  AGX_FORCE_INLINE agx::DynamicsSystem* Simulation::getDynamicsSystem()
  {
    return m_system.get();
  }
 
  AGX_FORCE_INLINE agx::Real Simulation::getTimeStep() const
  {
    if (m_system) return m_system->getTimeGovernor()->getTimeStep();
    else return 0;
  }
 
  AGX_FORCE_INLINE agx::Clock* Simulation::getClock()
  {
    return m_clock;
  }
 
  AGX_FORCE_INLINE const agx::Clock* Simulation::getClock() const
  {
    return m_clock;
  }
 
  AGX_FORCE_INLINE bool Simulation::allowCreateParticles() const
  {
    return m_allowCreateParticles;
  }
 
  AGX_FORCE_INLINE const agx::SolveModelRefVector& Simulation::getSolveModels() const
  {
    return m_solveModels;
  }
 
  template< typename T >
  T* Simulation::getConstraint( const agx::Uuid& uuid )
  {
    return dynamic_cast< T* >( this->getConstraint( uuid ) );
  }
 
  template< typename T >
  const T* Simulation::getConstraint( const agx::Uuid& uuid ) const
  {
    return dynamic_cast< const T* >( this->getConstraint( uuid ) );
  }
 
  template< typename T >
  T* Simulation::getConstraint( const agx::Name& name )
  {
    return dynamic_cast< T* >( this->getConstraint( name ) );
  }
 
  template< typename T >
  const T* Simulation::getConstraint( const agx::Name& name ) const
  {
    return dynamic_cast< const T* >( this->getConstraint( name ) );
  }
} // namespace agxSDK
 
#ifdef _MSC_VER
# pragma warning(pop) // C++ exception specification ignored except to indicate a function is not __declspec(nothrow). Restored.
#endif