vortexDebug.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2024 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file    vortexDebug.h
//! \brief   Provides debugging functionality for the Vortex physics engine integration
//! \ingroup vreVrfVortex
 
#pragma once
 
#include <vreVrfVortex/export.h>
 
#include "vreMessageManager/vreMessage.h"
 
#include "vreDebugManager/debugMetaRegister.h"
 
#include <Vx/VxMessage.h>
 
#include <deque>
 
class DtSimulationServices;
 
namespace makVre
{
class DtInitializer;
class DtCoordinateConvert;
class DtVortexCollisionProxyGenerator;
 
//! \brief Provides debugging capabilities for Vortex physics engine
//!
//! This class manages various debugging features for the Vortex physics integration,
//! including visualization of physics objects, collision triangles, and performance metrics.
//! It also handles configuration of the Vortex logging system and remote debugging.
class VREVRFVORTEX_DLL DtVortexDebug
{
public:
   //! \brief Custom log handler for Vortex physics engine messages
   //!
   //! Intercepts log messages from the Vortex physics engine and
   //! redirects them to the VR-Forces logging system, applying
   //! proper formatting and log level translation.
   class VREVRFVORTEX_DLL LogHandler
   {
   public:
      //! \brief Default constructor
      LogHandler() = default;
 
      //! \brief Destructor
      //!
      //! Resets the log handler if it wasn't already reset.
      virtual ~LogHandler();
 
      //! \brief Sets this handler as the active Vortex log handler
      //!
      //! Stores the previous log handler and installs this handler
      //! as the new Vortex log handler.
      virtual void setLogHandler();
 
      //! \brief Restores the original Vortex log handler
      //!
      //! Returns control to the previous log handler that was active
      //! before this handler was installed.
      virtual void resetLogHandler();
 
   protected:
      //! \brief Static callback function registered with Vortex
      //!
      //! This function is called by Vortex when log messages are generated.
      //! It formats the message and forwards it to the appropriate VR-Forces log.
      //!
      //! \param level The severity level of the log message
      //! \param format The format string for the log message
      //! \param ap Variable argument list containing values for the format string
      static void vortexLogHandler(Vx::eLogLevel level, const char* const format, va_list ap);
 
      //! \brief Helper function to format a log message with variable arguments
      //!
      //! \param str String reference where the formatted output will be stored
      //! \param fmt Format string
      //! \param ap Variable argument list
      //! \return True if formatting succeeded, false otherwise
      static bool formatToString(std::string& str, const char* const fmt, va_list ap);
 
   protected:
      Vx::LogHandler myOldLongHandler; //!< The previous log handler that was active
   };
 
public:
   //! \brief Constructor
   //!
   //! Initializes the debug system with the provided simulation services.
   //! Sets up default debug values and loads the debug configuration file.
   //!
   //! \param services Pointer to the simulation services
   explicit DtVortexDebug(const DtSimulationServices* services);
 
   //! \brief Destructor
   //!
   //! Performs cleanup of debug resources.
   virtual ~DtVortexDebug() = default;
 
   //! \brief Updates the debug state and visuals
   //!
   //! Called each simulation frame to update debug visualizations and process
   //! any pending debug operations.
   //!
   //! \param dt Time step in seconds since the last update
   virtual void tick(double dt);
 
   //! \brief Renders debug information using ImGui
   //!
   //! Displays debug information and controls in an ImGui interface.
   virtual void renderImgui();
 
   //! \brief Initializes Vortex debugging functionality
   //!
   //! Sets up the log handler and registers debug values with the debug manager.
   //! This makes the debugging options visible in the user interface.
   virtual void initializeVortexDebugging();
 
   //! \brief Shuts down Vortex debugging functionality
   //!
   //! Unregisters debug values and cleans up resources.
   virtual void shutdownVortexDebugging();
 
   //! \brief Checks if debugging is active
   //!
   //! \return True if debugging is active, false otherwise
   virtual bool active() const;
 
   //! \brief Checks if art parts debugging is enabled
   //!
   //! \return True if art parts debugging is enabled, false otherwise
   virtual bool debugArtParts() const;
 
   //! \brief Checks if contact point debugging is enabled
   //!
   //! \return True if contact point debugging is enabled, false otherwise
   virtual bool debugContacts() const;
 
   //! \brief Updates the Vortex remote debugging connection
   //!
   //! Enables or disables the Vortex remote debugger based on the current setting.
   virtual void updateVortexRemoteDebugging();
 
   //! \brief Checks if request bounds debugging is enabled
   //!
   //! \return True if request bounds debugging is enabled, false otherwise
   bool debugRequestBounds() const;
 
   //! \brief Checks if collision triangle debugging is enabled
   //!
   //! \return True if collision triangle debugging is enabled, false otherwise
   bool debugCollisionTriangles() const;
 
   //! \brief Checks if dynamic terrain debugging is enabled
   //!
   //! \return True if dynamic terrain debugging is enabled, false otherwise
   bool debugPrintDynamicTerrain() const;
 
   //! \brief Checks if pager timing debugging is enabled
   //!
   //! \return True if pager timing debugging is enabled, false otherwise
   bool debugPagerTimes() const;
 
   //! \brief Gets the timeout time for pager timing debugging
   //!
   //! \return The timeout time in seconds
   double debugPagerTimeoutTime() const;
 
   //! \brief Gets the Vortex log handler
   //!
   //! \return Shared pointer to the log handler
   std::shared_ptr<DtVortexDebug::LogHandler> logHandler();
 
protected:
   //! \brief Gets the debug initializer
   //!
   //! \return Pointer to the debug initializer
   makVre::DtInitializer* debugInitializer() const;
 
   //! \brief Handles debug messages from the debug manager
   //!
   //! Processes debug enable/disable messages and other control messages.
   //!
   //! \param msg The message to handle
   //! \return The result of handling the message
   makVre::DtVreMessageResult handleDebugMessage(makVre::DtVreMessage* msg);
 
   //! \brief Registers debug values with the debug manager
   //!
   //! Makes debug options visible in the user interface and sets up message handlers.
   virtual void registerDebugValues();
 
   //! \brief Unregisters debug values from the debug manager
   //!
   //! Removes debug options from the user interface and cleans up message handlers.
   virtual void unregisterDebugValues();
 
   //! \brief Sets the Vortex logging level
   //!
   //! Translates the VR-Forces notification level to the appropriate Vortex log level.
   //!
   //! \param notifyLevel The VR-Forces notification level
   static void setVortexLogLevel(DtNotifyLevelType notifyLevel);
 
protected:
   makVre::DtInitializer* myDebugInitializer;                     //!< Initializer for debug configuration
 
   DtSimulationAddress mySimAddress;                              //!< Address of the simulation
   DebugMetaRegisterMessage::Process myProcessType;               //!< Type of process (VRF or VRE)
 
   bool myActive;                                                 //!< Flag indicating if debugging is active
 
   bool myDebugRequestBounds;                                     //!< Flag for debug request bounds visualization
   bool myDebugPagerTimes;                                        //!< Flag for pager timing debug output
   bool myDebugPrintDynamicTerrain;                               //!< Flag for dynamic terrain debug output
   double myDebugTerrainPageoutTime;                              //!< Timeout for terrain paging
   bool myDebugArtParts;                                          //!< Flag for art parts visualization
   bool myDebugContacts;                                          //!< Flag for contact points visualization
   bool myDebugRemoteEnabled;                                     //!< Flag for remote debugging
 
   bool myDebugCollisionTriangles;                                //!< Flag for collision triangle visualization
   double myDebugCollisionTrianglesInterval;                      //!< Time interval between triangle updates
   unsigned int myDebugCollisionTrianglesMaxRequestCount;            //!< Counter for triangle requests
   double myCollisionTrianglesLastDtSent;                         //!< Time of last triangle data sent
 
   std::shared_ptr<DtVortexDebug::LogHandler> myVortexLogHandler; //!< Log handler for Vortex messages
 
   std::deque<std::pair<int, std::vector<DtVector>>> myCollisionGeometryDeque; //!< Queue of collision geometries for
                                                                               //!< visualization
 
   std::deque<std::pair<unsigned int, std::vector<DtVector>>> myArtPartsGeometryDeque;
   double myDebugArtPartsGeometryInterval;           //!< Time interval between part geometry updates
   unsigned int myDebugArtPartsGeometryMaxRequestCount; //!< Counter for geometry requests
   double myDebugArtPartsGeometryLastDtSent;
};
} // namespace makVre