rendering_engine::StatsOverlay Class Reference

Displays real-time frame statistics as a 2D overlay. More...

#include <stats_overlay.hpp>

Inherits rendering_engine::Actor2D.

Public Member Functions
	StatsOverlay (Scene &scene)
	Constructs a StatsOverlay actor. More...
void	Initialize () override
	Creates and positions overlay visual elements. More...
void	Update (float deltaTime) override
	Updates displayed statistics each frame. More...
Public Member Functions inherited from rendering_engine::Actor2D
	Actor2D (Scene &scene)
	Constructs a 2D actor associated with a Scene. More...
virtual	~Actor2D ()
virtual void	Initialize ()
	Initializes the actor after creation. More...
void	SetPosition (const glm::vec2 &position)
	Sets the actor's position in world space. More...
void	SetRotation (float angleDegrees)
	Sets the actor's rotation in degrees. More...
void	SetScale (const glm::vec2 &scale)
	Sets the actor's scale along each axis. More...
const glm::vec2 &	GetPosition () const
	Gets the actor 2d position. More...
float	GetRotation () const
	Gets the actor 2d rotation angle (degrees). More...
const glm::vec2 &	GetScale () const
	Gets the actor 2d scale. More...
SceneComponent2D &	GetTransform ()
	Access to the underlying SceneComponent2D (transform). More...
const SceneComponent2D &	GetTransform () const
virtual void	Update (float deltaTime)
	Updates actor logic and root transform state. More...
RenderResourceContext	GetRenderContext () const
	Returns the render resource context associated with this actor. More...
void	Destroy ()
	Requests deferred destruction of this 2D actor. More...
bool	IsPendingDestroy () const
	Indicates whether this actor is scheduled for destruction. More...
	Actor2D (const Actor2D &)=delete
Actor2D &	operator= (const Actor2D &)=delete

Additional Inherited Members
Protected Member Functions inherited from rendering_engine::Actor2D
virtual void	Shutdown ()
	Performs internal cleanup before destruction. More...
template<typename T , typename V >
T *	CreateSubobject (V arg)
	Creates and attaches a 2D drawable subobject to this actor. More...
Scene &	GetScene ()
	Returns the owning Scene. More...
template<>
Rectangle2D *	CreateSubobject (Rectangle2D::Properties prop)
template<>
TextBlock2D *	CreateSubobject (TextBlock2D::Properties prop)
Protected Attributes inherited from rendering_engine::Actor2D
SceneComponent2D	mRootComponent
bool	bUpdateOnTick
bool	bPendingDestroy = false

Detailed Description

Displays real-time frame statistics as a 2D overlay.

StatsOverlay renders a simple performance panel containing:

• FPS
• Frame duration (ms)
• Update time (ms)
• Draw time (ms)

The overlay is drawn in screen space using Rectangle2D and TextBlock2D subobjects. Values are updated every frame using FrameMetrics obtained from the active application.

Intended for debugging and performance diagnostics.

Definition at line 31 of file stats_overlay.hpp.

Constructor & Destructor Documentation

StatsOverlay()

rendering_engine::StatsOverlay::StatsOverlay

(

Scene &

scene

)

Constructs a StatsOverlay actor.

Reads configuration options and prepares internal state.

Parameters

scene

Reference to the owning scene.

Definition at line 16 of file stats_overlay.cpp.

    :
    Actor2D(scene),
    mFPSLabel(nullptr),
    mFPSValue(nullptr),
    mFrameLabel(nullptr),
    mFrameValue(nullptr),
    mUpdateLabel(nullptr),
    mUpdateValue(nullptr),
    mDrawLabel(nullptr),
    mDrawValue(nullptr)
{
    bUseSmoothedFPS = Utility::ReadConfigFile().useSmoothedFPS;
}

Member Function Documentation

Initialize()

void rendering_engine::StatsOverlay::Initialize ( )

overridevirtual

Creates and positions overlay visual elements.

Spawns background rectangle and label/value text blocks, attaches them to the root component, and arranges them in a two-column layout.

Reimplemented from rendering_engine::Actor2D.

Definition at line 31 of file stats_overlay.cpp.

{
    Actor2D::Initialize();
 
    bUpdateOnTick = true;
 
    TextBlock2D::Properties tbProp;
    tbProp.fontName = "RobotoMono-Medium";
 
    const float vertDelta = 25.0f;
    const float width = 140.0f;
    const float pad = 5.0f;
    const float height = vertDelta * 4;
 
    Rectangle2D::Properties rectangleProp;
    rectangleProp.color = mBgColor;
    rectangleProp.size = { width, height };
    mBackGround = CreateSubobject<Rectangle2D>(rectangleProp);
    mBackGround->GetTransform().AttachTo(&mRootComponent);
 
    const float middleX = width / 2.0f;
    const float middleY = height / 2.0f;
    const float column_0 = -middleX + pad;
    const float column_1 = column_0 + middleX + pad;
 
    const float row_0 = -middleY + tbProp.fontSize + pad;
    const float row_1 = row_0 + vertDelta;
    const float row_2 = row_1 + vertDelta;
    const float row_3 = row_2 + vertDelta;
    
    mFPSLabel = CreateSubobject<TextBlock2D>(tbProp);
    mFPSLabel->GetTransform().AttachTo(&mRootComponent);
    mFPSLabel->SetText("FPS:");
    mFPSLabel->SetPosition(glm::vec2(column_0, row_0));
 
    mFPSValue = CreateSubobject<TextBlock2D>(tbProp);
    mFPSValue->GetTransform().AttachTo(&mRootComponent);
    mFPSValue->SetPosition(glm::vec2(column_1, row_0));
 
    mFrameLabel = CreateSubobject<TextBlock2D>(tbProp);
    mFrameLabel->GetTransform().AttachTo(&mRootComponent);
    mFrameLabel->SetText("Frame:");
    mFrameLabel->SetPosition(glm::vec2(column_0, row_1));
 
    mFrameValue = CreateSubobject<TextBlock2D>(tbProp);
    mFrameValue->GetTransform().AttachTo(&mRootComponent);
    mFrameValue->SetPosition(glm::vec2(column_1, row_1));
 
    mUpdateLabel = CreateSubobject<TextBlock2D>(tbProp);
    mUpdateLabel->GetTransform().AttachTo(&mRootComponent);
    mUpdateLabel->SetText("Update:");
    mUpdateLabel->SetPosition(glm::vec2(column_0, row_2));
 
    mUpdateValue = CreateSubobject<TextBlock2D>(tbProp);
    mUpdateValue->GetTransform().AttachTo(&mRootComponent);
    mUpdateValue->SetPosition(glm::vec2(column_1, row_2));
 
    mDrawLabel = CreateSubobject<TextBlock2D>(tbProp);
    mDrawLabel->GetTransform().AttachTo(&mRootComponent);
    mDrawLabel->SetText("Draw:");
    mDrawLabel->SetPosition(glm::vec2(column_0, row_3));
 
    mDrawValue = CreateSubobject<TextBlock2D>(tbProp);
    mDrawValue->GetTransform().AttachTo(&mRootComponent);
    mDrawValue->SetPosition(glm::vec2(column_1, row_3));
}

Update()

void rendering_engine::StatsOverlay::Update ( float  deltaTime )

overridevirtual

Updates displayed statistics each frame.

Retrieves FrameMetrics from the active application and updates value text blocks accordingly.

Parameters

deltaTime

Time elapsed since previous frame (ms).

Reimplemented from rendering_engine::Actor2D.

Definition at line 98 of file stats_overlay.cpp.

{
    Actor2D::Update(deltaTime);
 
    mTimeAccumulator += deltaTime;
    if (mTimeAccumulator < mUpdateInterval)
        return;
 
    mTimeAccumulator = 0.0f;
 
    const auto frameMetrics = GetScene().GetSceneManager().GetApplication()->GetFrameMetrics();
    
    float fps = 0.0f;
    if (bUseSmoothedFPS)
    {
        fps = frameMetrics.fpsSmoothed;
    }
    else
    {
        fps = frameMetrics.fpsRaw;
    }
 
    char bufferFPS[16];
    std::snprintf(bufferFPS, sizeof(bufferFPS), "%.2f", fps);
    mFPSValue->SetText(bufferFPS);
 
    char bufferFrame[16];
    std::snprintf(bufferFrame, sizeof(bufferFrame), "%.2f", frameMetrics.frameDurationMs);
    mFrameValue->SetText(bufferFrame);
 
    char bufferUpdate[16];
    std::snprintf(bufferUpdate, sizeof(bufferUpdate), "%.2f", frameMetrics.updateTimeMs);
    mUpdateValue->SetText(bufferUpdate);
 
    char bufferDraw[16];
    std::snprintf(bufferDraw, sizeof(bufferDraw), "%.2f", frameMetrics.drawTimeMs);
    mDrawValue->SetText(bufferDraw);
}

---

The documentation for this class was generated from the following files:

• stats_overlay.hpp
• stats_overlay.cpp