debugRenderCommands.h

Go to the documentation of this file.

/*********************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*********************************************************************************/
 
//! \file debugRenderCommands.h
//! \ingroup vreDebugManager
//! \brief Contains the debug rendering command classes for the VREngage debug system.
//!
//! This file defines various debug rendering command classes that are used by the
//! debug renderer to render visual debug elements in the VREngage environment.
//! These commands support different types of primitives like spheres, cubes, lines,
//! triangles, and text (both 2D and 3D).
 
#pragma once
 
#include "vreDebugManager/export.h"
#include "vreDebugManager/debugRenderer.h"
 
#include <list>
 
namespace makVre
{
//! \brief Command namespace for debug rendering commands
 
//! \brief Command for drawing a debug sphere in 3D space
//!
//! Renders a sphere at the specified position with the given radius and color
class DEBUGMANAGER_DLL DebugDrawSphereCommand : public DtDebugDrawCommand
{
public:
   //! \brief Constructor for sphere drawing command
   //! \param position Center position of the sphere
   //! \param radius Radius of the sphere
   //! \param c Color of the sphere
   //! \param fill Fill mode (solid, wireframe, etc.)
   //! \param clip Whether to clip the sphere against the view frustum
   //! \param time Duration in seconds for this command to remain active
   DebugDrawSphereCommand(const DtVector& position, const double& radius, const DtColor& c, DtColor::Fill fill,
      bool clip, const double& time);
 
   //! \brief Virtual destructor
   virtual ~DebugDrawSphereCommand() override;
 
   virtual void draw(DtDebugCanvas& canvas) override;
 
protected:
   //! \brief Center position of the sphere
   DtVector myPosition;
   //! \brief Radius of the sphere
   double myRadius;
};
 
//! \brief Command for drawing a debug cube in 3D space
//!
//! Renders an axis-aligned cube defined by its min and max corner points
class DEBUGMANAGER_DLL DebugDrawCubeCommand : public DtDebugDrawCommand
{
public:
   //! \brief Constructor for cube drawing command
   //! \param start Minimum corner point of the cube
   //! \param end Maximum corner point of the cube
   //! \param c Color of the cube
   //! \param fill Fill mode (solid, wireframe, etc.)
   //! \param clip Whether to clip the cube against the view frustum
   //! \param time Duration in seconds for this command to remain active
   DebugDrawCubeCommand(
      const DtVector& start, const DtVector& end, const DtColor& c, DtColor::Fill fill, bool clip, const double& time);
 
   //! \brief Virtual destructor
   virtual ~DebugDrawCubeCommand() override;
 
   virtual void draw(DtDebugCanvas& canvas) override;
 
protected:
   DtVector myStart;
   DtVector myEnd;
};
 
//! \brief Command for drawing a debug line in 3D space
//!
//! Renders a straight line between two points
class DEBUGMANAGER_DLL DebugDrawLineCommand : public DtDebugDrawCommand
{
public:
   //! \brief Constructor for line drawing command
   //! \param start Start point of the line
   //! \param end End point of the line
   //! \param c Color of the line
   //! \param clip Whether to clip the line against the view frustum
   //! \param time Duration in seconds for this command to remain active
   DebugDrawLineCommand(const DtVector& start, const DtVector& end, const DtColor& c, bool clip, const double& time);
 
   //! \brief Virtual destructor
   virtual ~DebugDrawLineCommand() override;
 
   virtual void draw(DtDebugCanvas& canvas) override;
 
protected:
   DtVector myStart;
   DtVector myEnd;
};
 
//! \brief Command for drawing debug triangles in 3D space
//!
//! Renders a set of triangles defined by a list of vertex points
class DEBUGMANAGER_DLL DebugDrawTrisCommand : public DtDebugDrawCommand
{
public:
   //! \brief Constructor for triangle drawing command
   //! \param points List of triangle vertices (should be multiples of 3)
   //! \param c Color of the triangles
   //! \param fill Fill mode (solid, wireframe, etc.)
   //! \param clip Whether to clip the triangles against the view frustum
   //! \param time Duration in seconds for this command to remain active
   DebugDrawTrisCommand(
      const std::vector<DtVector>& points, const DtColor& c, DtColor::Fill fill, bool clip, const double& time);
 
   //! \brief Virtual destructor
   virtual ~DebugDrawTrisCommand() override;
 
   virtual void draw(DtDebugCanvas& canvas) override;
 
protected:
   //! \brief List of triangle vertices
   std::vector<DtVector> myPoints;
};
 
//! \brief Command for drawing 3D text in the 3D world
//!
//! Renders text at a specific 3D position in world space
class DEBUGMANAGER_DLL DebugDrawText3dCommand : public DtDebugDrawCommand
{
public:
   //! \brief Constructor for 3D text drawing command
   //! \param position Position in 3D space where the text should appear
   //! \param text The text to display
   //! \param c Color of the text
   //! \param clip Whether to clip the text against the view frustum
   //! \param time Duration in seconds for this command to remain active
   DebugDrawText3dCommand(
      const DtVector& position, const std::string& text, const DtColor& c, bool clip, const double& time);
 
   //! \brief Virtual destructor
   virtual ~DebugDrawText3dCommand() override;
 
   virtual void draw(DtDebugCanvas& canvas) override;
 
protected:
   DtVector myPosition;
   std::string myText;
};
 
//! \brief Command for drawing 2D text on the screen
//!
//! Renders text at a specific 2D position in screen space
class DEBUGMANAGER_DLL DebugDrawText2dCommand : public DtDebugDrawCommand
{
public:
   //! \brief Constructor for 2D text drawing command
   //! \param position Position in screen space where the text should appear
   //! \param text The text to display
   //! \param c Color of the text
   //! \param time Duration in seconds for this command to remain active
   DebugDrawText2dCommand(const DtVector& position, const std::string& text, const DtColor& c, const double& time);
 
   //! \brief Virtual destructor
   virtual ~DebugDrawText2dCommand() override;
 
   virtual void draw(DtDebugCanvas& canvas) override;
 
protected:
   DtVector myPosition;
   std::string myText;
};
 
//! \brief Command for drawing a debug graph on the screen
//!
//! Renders a real-time graph to visualize data points over time
class DEBUGMANAGER_DLL DebugDrawGraphCommand : public DtDebugDrawCommand
{
public:
   //! \brief Constructor for graph drawing command
   //! \param name Name of the graph
   //! \param c Color of the graph
   //! \param time Duration in seconds for this command to remain active
   DebugDrawGraphCommand(const std::string& name, const DtColor& c, const double& time);
 
   //! \brief Virtual destructor
   virtual ~DebugDrawGraphCommand() override;
 
   virtual void draw(DtDebugCanvas& canvas) override;
 
   const std::string& name() { return myName; }
   //! \brief Adds a data point to the graph
   //! \param point The data point value to add
   void addPoint(double point);
   void setScreenPosition(const DtVector& screenPos) { myScreenPosition = screenPos; }
 
   //! \brief Gets the default size of the graph
   //! \return The default width/height of the graph in pixels
   static float theGraphSize() { return 200.0f; }
 
protected:
   //! \brief Time at which the graph should reset
   double myResetTime;
   //! \brief Name of the graph
   std::string myName;
   //! \brief Collection of data points to plot
   std::vector<double> myPoints;
   //! \brief Current point index
   int myCurrentPoint;
   //! \brief Minimum value in the graph
   double myMin;
   //! \brief Maximum value in the graph
   double myMax;
   //! \brief Position of the graph on the screen
   DtVector myScreenPosition;
};
 
//! \brief Command for drawing a debug text panel on the screen
//!
//! Renders a panel of text that can be updated with new lines
class DEBUGMANAGER_DLL DebugDrawTextPanelCommand : public DtDebugDrawCommand
{
public:
   //! \brief Constructor for text panel drawing command
   //! \param name Name of the text panel
   //! \param c Color of the text
   //! \param time Duration in seconds for this command to remain active
   DebugDrawTextPanelCommand(const std::string& name, const DtColor& c, const double& time);
 
   //! \brief Virtual destructor
   virtual ~DebugDrawTextPanelCommand() override;
 
   virtual void draw(DtDebugCanvas& canvas) override;
 
   const std::string& name() { return myName; }
   //! \brief Adds a line of text to the panel
   //! \param point The text line to add
   //! \param scroll Whether to automatically scroll to show newest text
   void addText(const std::string& point, bool scroll = false);
   void setScreenPosition(const DtVector& screenPos) { myScreenPosition = screenPos; }
 
   //! \brief Gets the default size of the text panel
   //! \return The default width of the panel in pixels
   static float thePanelSize() { return 320.0f; }
 
protected:
   //! \brief Time at which the panel should reset
   double myResetTime;
   //! \brief Name of the text panel
   std::string myName;
   //! \brief Collection of text lines to display
   std::list<std::string> myText;
   //! \brief Current text index
   int myCurrentText;
   //! \brief Position of the panel on the screen
   DtVector myScreenPosition;
};
 
} // namespace makVre