vreRtdTickCallback.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreRtdTickCallback.h
//! \ingroup vreVrfRtd
//! \brief Tick callback handler for VREngage RTD components
//!
//! This file defines the DtVreRtdTickCallback class, which manages the periodic
//! updating of RTD simulation states during each simulation frame in the VREngage
//! environment. It handles time synchronization between RTD and VRF systems.
 
#pragma once
 
#include <vreVrfRtd/vreRtdBackendLibCommon.h>
#include <vreVrfRtd/vreRtdGlobal.h>
 
#include <vrfcgf/cgf.h>
#include <vrfutil/profiler.h>
 
#include <vrfobjcore/localObject.h>
 
 
namespace vreRtd
{
//! \brief Tick callback handler for VREngage RTD components
//!
//! This singleton class manages the periodic updating of RTD simulation states
//! during each simulation frame. It synchronizes the time between the RTD and VRF
//! systems, and handles environmental updates such as wind conditions.
class RTD_VRF_BACKEND_PLUGIN_EXPORT DtVreRtdTickCallback
{
public:
   //! \brief Default constructor
   //!
   //! Initializes a new tick callback handler with default values.
   DtVreRtdTickCallback()
      : myFrameTimestamp(0)
      , myCurWindDir(0)
      , myCurWindSpeed(0)
   {
   }
 
   //! \brief Static callback function for frame ticks
   //! \param usr User data pointer (points to the tick callback instance)
   //!
   //! Called once per simulation frame to update the RTD world. This function
   //! synchronizes the RTD simulation time with the VRF exercise time and
   //! performs one or more RTD world updates as needed to keep the systems
   //! in sync.
   static void callback(void* usr)
   {
      DtVRF_PROFILE("vreRtd::tickCallback");
 
      DtVreRtdTickCallback* posttickcb = (DtVreRtdTickCallback*)usr;
 
      if (!DtVreRtdGlobal::getInstance()->cgf()->simulationServices()->isPaused())
      {
         // Update environmental conditions like wind
         posttickcb->updateWind();
 
         // Get current exercise time and fixed delta time
         DtTime exerciseTime = DtVreRtdGlobal::getInstance()->cgf()->simulationServices()->exerciseTime();
         smReal fixedDt = vreRtd::DtVreRtdGlobal::getInstance()->rtdWorld()->getFixedDeltaTime();
 
         // Subtract fixed delta time to avoid the simulation time of RTD exceeding the
         // VRF simulation time (see myTimeAccumulator of RTD world for details).
         // This doesn't consider time accumulator of world, so there may be
         // another update step after world update().
         smReal dt = exerciseTime - DtVreRtdGlobal::getInstance()->rtdWorld()->getSimulationTime() - fixedDt;
 
         // Ensure non-negative time step
         if (dt < 0)
         {
            dt = 0;
         }
 
         // Perform initial world update
         DtVreRtdGlobal::getInstance()->rtdWorld()->update(dt);
 
         // If there is enough time, make another update to catch up fully
         if (exerciseTime - DtVreRtdGlobal::getInstance()->rtdWorld()->getSimulationTime() >= fixedDt)
         {
            DtVreRtdGlobal::getInstance()->rtdWorld()->update(fixedDt);
         }
      }
   }
 
   //! \brief Singleton instance of the tick callback handler
   static DtVreRtdTickCallback* theInstance;
 
   //! \brief Gets the singleton instance of the tick callback handler
   //! \return Pointer to the singleton instance
   //!
   //! Returns the singleton instance of the tick callback handler, creating it
   //! if it doesn't already exist. This is the proper way to access the tick callback handler.
   static DtVreRtdTickCallback* getInstance()
   {
      if (theInstance == 0)
      {
         theInstance = new DtVreRtdTickCallback;
      }
 
      return theInstance;
   }
 
   //! \brief Updates the current wind conditions
   //!
   //! Updates the current wind direction and speed from the environment.
   //! This is called once per frame during the tick callback.
   void updateWind();
 
   //! \brief Timestamp of the current frame
   //!
   //! Stores the timestamp of the current frame for time synchronization.
   smReal myFrameTimestamp;
 
   //! \brief Current wind direction in radians
   double myCurWindDir;
 
   //! \brief Current wind speed in meters per second
   double myCurWindSpeed;
};
} // namespace vreRtd