StepEventCallback.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 <agxSDK/Simulation.h>
 
#include <array>
 
namespace agxUtil
{
  class AGXPHYSICS_EXPORT StepEventCallback : public agxSDK::StepEventListener
  {
    public:
      struct DefaultIsPreCollide
      {
        DefaultIsPreCollide( int activation = agxSDK::StepEventListener::PRE_COLLIDE )
          : activation( (agxSDK::StepEventListener::ActivationMask)activation )
        {
        }
 
        agxSDK::StepEventListener::ActivationMask activation{};
      };
 
    public:
      static void uninitialize( agxSDK::Simulation* simulation );
 
      static void removeMe( agxSDK::Simulation* simulation );
 
      template<typename FuncT, typename... Args>
      static void preCollide( FuncT&& callback, agxSDK::Simulation* simulation, Args&&... args );
 
      template<typename FuncT, typename... Args>
      static void pre( FuncT&& callback, agxSDK::Simulation* simulation, Args&&... args );
 
      template<typename FuncT, typename... Args>
      static void post( FuncT&& callback, agxSDK::Simulation* simulation, Args&&... args );
 
      template<typename FuncT, typename... Args>
      static void last( FuncT&& callback, agxSDK::Simulation* simulation, Args&&... args );
 
      template<typename FuncT, typename... Args>
      static void callAt( agx::Real timeStamp,
                          DefaultIsPreCollide callbackType,
                          FuncT&& callback,
                          agxSDK::Simulation* simulation,
                          Args&&... args );
 
      template<typename FuncT, typename... Args>
      static void callFor( agx::Real seconds,
                           DefaultIsPreCollide callbackType,
                           FuncT&& callback,
                           agxSDK::Simulation* simulation,
                           Args&&... args );
 
    protected:
      virtual ~StepEventCallback();
 
      virtual void addNotification() override;
 
      virtual void removeNotification() override;
 
      virtual void preCollide( const agx::TimeStamp& t ) override;
      virtual void pre( const agx::TimeStamp& t ) override;
      virtual void post( const agx::TimeStamp& t ) override;
      virtual void last( const agx::TimeStamp& t ) override;
 
    private:
      enum CallbackType
      {
        PRE_COLLIDE_TYPE,
        PRE_TYPE,
        POST_TYPE,
        LAST_TYPE,
        NUM_CALLBACK_TYPES
      };
 
      using Callback = std::function<void()>;
      struct TimedCallbackData
      {
        Callback callback{};
        CallbackType callbackType = PRE_COLLIDE_TYPE;
        agx::Real startTime = -1.0;
        agx::Real endTime = -1.0;
      };
 
      using StepCallbackVector = std::vector<Callback>;
      using TimedCallbackVector = std::vector<TimedCallbackData>;
      using StepEventCallbackRef = agx::ref_ptr<StepEventCallback>;
      using InstanceType = agx::HashTable<const agxSDK::Simulation*, StepEventCallbackRef>;
      using StepCallbacks = std::array<StepCallbackVector, (size_t)NUM_CALLBACK_TYPES>;
      using TimedCallbacks = std::array<TimedCallbackVector, (size_t)NUM_CALLBACK_TYPES>;
 
 
      struct InternalState
      {
        enum Flag : agx::UInt32
        {
          EXECUTING_CALLBACKS = 1 << 0,
          REMOVE_CURRENT_REQUEST = 1 << 1,
        };
        using Flags = agx::BitState<Flag, std::underlying_type_t<Flag>>;
        Flags flags;
 
        CallbackType currCallbackType = NUM_CALLBACK_TYPES;
        StepCallbackVector deferredStepCallbacks;
        TimedCallbackVector deferredTimedCallbacks;
 
        inline InternalState()
          : flags()
        {
        }
 
        inline bool removeRequestedAndResetState()
        {
          const auto removeRequested = flags.Is( REMOVE_CURRENT_REQUEST );
          flags.update( REMOVE_CURRENT_REQUEST, false );
          return removeRequested;
        }
 
        inline bool isExecutingCallbacks( CallbackType callbackType ) const
        {
          return currCallbackType != NUM_CALLBACK_TYPES && callbackType == currCallbackType;
        }
 
        inline void begin( CallbackType callbackType )
        {
          agxAssert( currCallbackType == NUM_CALLBACK_TYPES );
          agxAssert( !flags.Is( EXECUTING_CALLBACKS ) );
          agxAssert( deferredStepCallbacks.empty() );
          agxAssert( deferredTimedCallbacks.empty() );
          flags.update( EXECUTING_CALLBACKS, true );
          currCallbackType = callbackType;
        }
 
        inline void end( StepCallbackVector& stepCallbacks, TimedCallbackVector& timedCallbacks )
        {
          stepCallbacks.insert( stepCallbacks.end(),
                                deferredStepCallbacks.begin(),
                                deferredStepCallbacks.end() );
          deferredStepCallbacks.clear();
 
          timedCallbacks.insert( timedCallbacks.end(),
                                 deferredTimedCallbacks.begin(),
                                 deferredTimedCallbacks.end() );
          deferredTimedCallbacks.clear();
 
          flags.update( EXECUTING_CALLBACKS, false );
          currCallbackType = NUM_CALLBACK_TYPES;
        }
      };
 
    private:
      static StepEventCallback& getOrCreate( agxSDK::Simulation& simulation );
 
      static bool hasInstance( const agxSDK::Simulation* simulation );
 
      static void registerCallback( const Callback& callback,
                                    CallbackType callbackType,
                                    agxSDK::Simulation* simulation );
 
      static void registerCallback( agx::Real startTime,
                                    agx::Real endTime,
                                    DefaultIsPreCollide callbackType,
                                    const Callback& callback,
                                    agxSDK::Simulation* simulation );
 
    private:
      StepEventCallback();
 
      void executeCallbacks( const agx::TimeStamp& t, CallbackType callbackType );
 
    private:
      static InstanceType s_instances;
      StepCallbacks m_stepCallbacks;
      TimedCallbacks m_timedCallbacks;
      InternalState m_state;
  };
 
  template<typename FuncT, typename... Args>
  void StepEventCallback::preCollide( FuncT&& callback, agxSDK::Simulation* simulation, Args&&... args )
  {
    if ( simulation == nullptr )
      return;
 
    registerCallback( std::bind( std::forward<FuncT>( callback ),
                                 simulation,
                                 std::forward<Args>( args )... ),
                      PRE_COLLIDE_TYPE,
                      simulation );
  }
 
  template<typename FuncT, typename... Args>
  void StepEventCallback::pre( FuncT&& callback, agxSDK::Simulation* simulation, Args&&... args )
  {
    if ( simulation == nullptr )
      return;
 
    registerCallback( std::bind( std::forward<FuncT>( callback ),
                                 simulation,
                                 std::forward<Args>( args )... ),
                      PRE_TYPE,
                      simulation );
  }
 
  template<typename FuncT, typename... Args>
  void StepEventCallback::post( FuncT&& callback, agxSDK::Simulation* simulation, Args&&... args )
  {
    if ( simulation == nullptr )
      return;
 
    registerCallback( std::bind( std::forward<FuncT>( callback ),
                                 simulation,
                                 std::forward<Args>( args )... ),
                      POST_TYPE,
                      simulation );
  }
 
  template<typename FuncT, typename... Args>
  void StepEventCallback::last( FuncT&& callback, agxSDK::Simulation* simulation, Args&&... args )
  {
    if ( simulation == nullptr )
      return;
 
    registerCallback( std::bind( std::forward<FuncT>( callback ),
                                 simulation,
                                 std::forward<Args>( args )... ),
                      LAST_TYPE,
                      simulation );
  }
 
  template<typename FuncT, typename... Args>
  void StepEventCallback::callAt( agx::Real timeStamp,
                                  DefaultIsPreCollide callbackType,
                                  FuncT&& callback,
                                  agxSDK::Simulation* simulation,
                                  Args&&... args )
  {
    registerCallback( timeStamp,
                      timeStamp,
                      callbackType,
                      std::bind( std::forward<FuncT>( callback ),
                                 simulation,
                                 std::forward<Args>( args )... ),
                      simulation );
  }
 
  template<typename FuncT, typename... Args>
  void StepEventCallback::callFor( agx::Real seconds,
                                   DefaultIsPreCollide callbackType,
                                   FuncT&& callback,
                                   agxSDK::Simulation* simulation,
                                   Args&&... args )
  {
    if ( simulation == nullptr )
      return;
 
    registerCallback( simulation->getTimeStamp(),
                      simulation->getTimeStamp() + seconds,
                      callbackType,
                      std::bind( std::forward<FuncT>( callback ),
                                 simulation,
                                 std::forward<Args>( args )... ),
                      simulation );
  }
}