debugRenderer.h

Go to the documentation of this file.

/*********************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*********************************************************************************/
 
//! \file debugRenderer.h
//! \ingroup vreDebugManager
//! \brief Contains the debug renderer class for the VREngage debug system.
//!
//! This file defines the debug renderer classes which handle 2D and 3D visual debug
//! elements in the VREngage environment. The renderer manages debug draw commands,
//! layer visibility, and integration with the graphics engine.
 
#pragma once
 
#include "vreDebugManager/export.h"
#include "vreDebugManager/debugRendererDefines.h"
 
#include "vreUtil/color.h"
 
#include <matrix/vlVector.h>
 
#include <osg/Drawable>
 
#include <list>
 
 
namespace makVrv
{
class DtDe;
class DtOsgChannel;
} // namespace makVrv
 
namespace makVre
{
class DtDebugCanvas;
class DtVreDebugManager;
 
//! \brief Base class for all debug draw commands
//!
//! This abstract base class defines the interface for all debug drawing commands.
//! It provides common functionality for handling color, fill mode, clipping, and
//! lifetime management of debug visuals.
class DEBUGMANAGER_DLL DtDebugDrawCommand
{
public:
   //! \brief Constructor for debug draw commands
   //! \param color Color of the debug visual
   //! \param fill Fill mode (solid, wireframe, etc.)
   //! \param clip Whether to clip against the view frustum
   //! \param time Duration in seconds for this command to remain active
   //! \param is3D Whether this is a 3D or 2D debug visual
   DtDebugDrawCommand(DtColor color, DtColor::Fill fill, bool clip, const double& time, bool is3D)
      : myColor(color)
      , myFill(fill)
      , myTime(time)
      , myClip(clip)
      , my3D(is3D)
   {
   }
   //! \brief Virtual destructor
   virtual ~DtDebugDrawCommand() {}
 
   //! \brief Pure virtual draw method that must be implemented by derived classes
   //! \param drawList Canvas to draw the debug visual on
   virtual void draw(DtDebugCanvas& drawList) = 0;
   //! \brief Reduces the remaining display time for this command
   //! \param delta Time in seconds to subtract from the remaining time
   virtual void reduceTime(double delta) { myTime -= delta; }
   //! \brief Checks if this command has expired
   //! \return True if the command's display time has elapsed
   virtual bool ended() { return myTime <= 0; }
   //! \brief Checks if this is a 3D visual
   //! \return True if this is a 3D visual, false if 2D
   virtual bool get3D() { return my3D; }
 
protected:
   //! \brief Eye position for view-dependent debug visuals
   DtVector myEyepoint;
   //! \brief Color of the debug visual
   DtColor myColor;
   //! \brief Fill mode for the debug visual
   DtColor::Fill myFill;
   //! \brief Remaining time in seconds for display
   double myTime;
   //! \brief Whether to clip against the view frustum
   bool myClip;
   //! \brief Whether this is a 3D visual
   bool my3D;
};
 
//! \brief Parameters for debug rendering
//!
//! Contains all the necessary parameters for rendering debug visuals,
//! including screen dimensions, view matrices, and observer position.
struct DEBUGMANAGER_DLL DtDebugRenderParameters
{
   //! \brief Width of the screen in pixels
   float screenWidth;
   //! \brief Height of the screen in pixels
   float screenHeight;
   //! \brief Whether rendering in 3D mode
   bool is3d;
   //! \brief Orthographic projection matrix
   float ortho[16];
   //! \brief Perspective projection matrix
   float perspective[16];
   //! \brief View matrix
   float view[16];
   //! \brief Observer position
   DtVector obsPos;
 
   //! \brief Default constructor
   //!
   //! Initializes all parameters to zero
   DtDebugRenderParameters()
   {
      // initialize all memory to 0
      memset(this, 0, sizeof(DtDebugRenderParameters));
   }
};
 
//! \brief Debug renderer for 2D and 3D debug visuals
//!
//! This class manages the rendering of all debug visuals in the VREngage environment.
//! It handles layers, visibility controls, and integration with the graphics engine.
class DEBUGMANAGER_DLL DtDebugRenderer
{
public:
   //! \brief Constructor for debug renderer
   //! \param de Reference to the graphics engine
   DtDebugRenderer(makVrv::DtDe& de);
 
   //! \brief Virtual destructor
   virtual ~DtDebugRenderer();
 
   //! \brief Main rendering function for debug visuals
   //! \param context Graphics context for rendering
   //! \param params Rendering parameters including view and projection matrices
   //! \return True if rendering was successful
   virtual bool render(void* context, DtDebugRenderParameters& params);
 
   //! \brief Checks if debug rendering is enabled
   //! \return True if debug rendering is enabled
   virtual bool isEnabled();
   //! \brief Enables or disables debug rendering
   //! \param setting True to enable debug rendering, false to disable
   virtual void setEnabled(bool setting);
 
   //! \brief Gets the names of all available debug layers
   //! \param timeoutTime Timeout in seconds to filter inactive layers
   //! \param group Group name to filter layers by
   //! \return Vector of pairs containing layer ID and display name
   virtual std::vector<std::pair<std::string, std::string>> layerNames(
      double timeoutTime = 0.f, const std::string& group = "");
   //! \brief Enables or disables a specific debug layer
   //! \param layerName Name of the layer to modify
   //! \param setting True to enable the layer, false to disable
   virtual void setLayerEnabled(const std::string& layerName, bool setting);
   //! \brief Checks if a specific debug layer is enabled
   //! \param layerName Name of the layer to check
   //! \return True if the layer is enabled
   virtual bool isLayerEnabled(const std::string& layerName);
 
   //! \brief Debug callback function
   //!
   //! Called to trigger any debug-specific processing
   virtual void debugCallback();
 
   //! \brief Gets the render timeout value
   //! \return Timeout value in seconds
   float getRenderTimeout();
 
   //! \brief Sets the render timeout value
   //! \param timeout Timeout value in seconds
   void setRenderTimeout(float timeout);
 
protected:
   friend DtVreDebugManager;
 
   //! \brief Adds a draw command to a specific layer
   //! \param layerId ID of the layer
   //! \param layerName Display name of the layer
   //! \param cmd Pointer to the draw command to add
   void addDrawCmd(const std::string& layerId, const std::string& layerName, DtDebugDrawCommand* cmd);
 
   //! \brief Handles sphere drawing messages
   //! \param msg Pointer to the message containing sphere drawing parameters
   //! \return Result of the message handling
   virtual makVre::DtVreMessageResult handleDrawSphere(makVre::DtVreMessage* msg);
 
   //! \brief Handles line drawing messages
   //! \param msg Pointer to the message containing line drawing parameters
   //! \return Result of the message handling
   virtual makVre::DtVreMessageResult handleDrawLine(makVre::DtVreMessage* msg);
 
   //! \brief Handles cube drawing messages
   //! \param msg Pointer to the message containing cube drawing parameters
   //! \return Result of the message handling
   virtual makVre::DtVreMessageResult handleDrawCube(makVre::DtVreMessage* msg);
 
   //! \brief Handles triangle drawing messages
   //! \param msg Pointer to the message containing triangle drawing parameters
   //! \return Result of the message handling
   virtual makVre::DtVreMessageResult handleDrawTris(makVre::DtVreMessage* msg);
 
   //! \brief Handles 3D text drawing messages
   //! \param msg Pointer to the message containing 3D text drawing parameters
   //! \return Result of the message handling
   virtual makVre::DtVreMessageResult handleDrawText3d(makVre::DtVreMessage* msg);
 
   //! \brief Handles 2D text drawing messages
   //! \param msg Pointer to the message containing 2D text drawing parameters
   //! \return Result of the message handling
   virtual makVre::DtVreMessageResult handleDrawText2d(makVre::DtVreMessage* msg);
 
   //! \brief Handles graph drawing messages
   //! \param msg Pointer to the message containing graph drawing parameters
   //! \return Result of the message handling
   virtual makVre::DtVreMessageResult handleDrawGraph(makVre::DtVreMessage* msg);
 
   //! \brief Handles text panel drawing messages
   //! \param msg Pointer to the message containing text panel drawing parameters
   //! \return Result of the message handling
   virtual makVre::DtVreMessageResult handleDrawTextPanel(makVre::DtVreMessage* msg);
 
protected:
   //! \brief Reference to the graphics engine
   makVrv::DtDe& myDe;
 
   //! \brief Main screen height in pixels
   float myMainScreenHeight;
   //! \brief Main screen width in pixels
   float myMainScreenWidth;
   //! \brief Timeout for debug menu visibility
   float myDebugMenuTimeout;
 
   //! \brief Structure for a debug rendering layer
   //!
   //! Contains all the settings and draw commands for a single debug layer
   struct DrawLayer
   {
      //! \brief Display name of the layer
      std::string myLayerMapDisplayName;
      //! \brief Whether the layer is enabled
      bool myIsEnabled;
      //! \brief Time since last update
      double mySinceLastUpdateTime;
      //! \brief Whether this is a 3D layer
      bool myIs3D;
      //! \brief List of draw commands for this layer
      std::list<DtDebugDrawCommand*> myDrawList;
 
      //! \brief Default constructor initializing layer as disabled
      DrawLayer()
         : myIsEnabled(false)
         , mySinceLastUpdateTime(0.f)
         , myIs3D(false)
      {
      }
   };
   //! \brief Map of layer IDs to layer data
   using DrawLayerMap = std::map<std::string, DrawLayer>;
   //! \brief Iterator for the draw layer map
   using DrawLayerMapIter = DrawLayerMap::iterator;
   //! \brief Map of all debug layers
   DrawLayerMap myDrawLayerMap;
 
   //! \brief Flag indicating if debug rendering is enabled
   bool myIsEnabled;
 
   //! \brief Map of canvases for different rendering contexts
   using CanvasMap = std::map<std::pair<void*, bool>, DtDebugCanvas*>;
   //! \brief Map of all debug canvases
   CanvasMap myCanvasMap;
 
   //! \brief 2D drawable for rendering debug elements
   osg::ref_ptr<osg::Drawable> my2dDrawable;
   //! \brief 3D drawable for rendering debug elements
   osg::ref_ptr<osg::Drawable> my3dDrawable;
 
   //! \brief Font filename for text rendering
   DtFilename myFontFilename;
   //! \brief Vertex shader filename
   DtFilename myVsFilename;
   //! \brief Fragment shader filename
   DtFilename myFsFilename;
};
 
} // namespace makVre