osgSensorViewTimeOverlaySection.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file osgSensorViewTimeOverlaySection.h
//! \brief Defines the time display overlay section for sensor views
//!
//! This file contains the DtOsgSensorViewTimeOverlaySection class which
//! provides a sensor view overlay that displays the current simulation time.
//! This information helps users track the time within the simulation environment.
 
#pragma once
 
#include "vrePlayerStation/export.h"
 
#include <vrvOsg/DtOsgSensorViewOverlaySection.h>
 
namespace makVrv
{
//! \brief Forward declaration of the display engine class
class DtDe;
 
//! \brief Forward declaration of the text proxy class
class DtTextProxy;
 
//! \brief Forward declaration of the overlay renderer class
class DtOverlayRenderer;
} // namespace makVrv
 
//! \brief Overlay section that displays current simulation time in sensor views
//!
//! DtOsgSensorViewTimeOverlaySection provides a sensor view overlay that
//! displays the current simulation time. This is useful for mission timing,
//! coordination, and after-action review. The time is typically displayed in
//! a standard format (HH:MM:SS) positioned in a non-intrusive location on
//! the sensor view.
class PLAYERSTATION_DLL DtOsgSensorViewTimeOverlaySection : public makVrv::DtOsgSensorViewOverlaySection
{
public:
   //! \brief Friend declaration for creator class
   //!
   //! Only the creator class can construct instances of this section.
   friend class DtOsgSensorViewTimeOverlaySectionCreator;
 
   //! \brief Destructor
   //!
   //! Cleans up resources used by the time overlay section,
   //! particularly the text display objects.
   virtual ~DtOsgSensorViewTimeOverlaySection() override;
 
   //! \brief Initializes the overlay section
   //! \param overlayRenderer Renderer for creating overlay elements
   //! \param windowWidth Width of the window in pixels
   //! \param windowHeight Height of the window in pixels
   //! \param channelXOffset X offset of the channel in pixels
   //! \param channelYOffset Y offset of the channel in pixels
   //!
   //! Initializes the overlay section by creating the text element that displays
   //! the simulation time. This must be called prior to any update calls. The position
   //! of the text is calculated based on the window dimensions and channel offsets.
   virtual void initialize(makVrv::DtOverlayRenderer& overlayRenderer, unsigned int windowWidth,
      unsigned int windowHeight, unsigned int channelXOffset, unsigned int channelYOffset) override;
 
   //! \brief Updates the overlay when the channel size changes
   //! \param windowWidth New width of the window in pixels
   //! \param windowHeight New height of the window in pixels
   //! \param channelXOffset New X offset of the channel in pixels
   //! \param channelYOffset New Y offset of the channel in pixels
   //!
   //! Adjusts the position and size of the text element when the channel
   //! dimensions or position change. This ensures the time display
   //! maintains its relative position in the view.
   virtual void setChannelSize(unsigned int windowWidth, unsigned int windowHeight, unsigned int channelXOffset,
      unsigned int channelYOffset) override;
 
   //! \brief Updates the time display
   //! \param observer Observer object representing the viewer's position and orientation
   //! \param state Current state of the sensor field of view
   //!
   //! Updates the overlay text with the current simulation time during each
   //! frame update. The time format is typically HH:MM:SS and is retrieved from
   //! the simulation environment rather than the system clock.
   virtual void update(const makVrv::DtOsgObserverObject& observer,
      const makVrv::DtSensorFieldOfViewData& state) override;
 
   //! \brief Gets the unique name of this overlay section
   //! \return Reference to the section name string
   //!
   //! Returns the name of this section with which it may be retrieved from
   //! the DtOsgSensorViewOverlay. Each section type has a unique name.
   virtual const std::string& sectionName() const override;
 
public:
   //! \brief Static constant defining the section name
   //!
   //! This string identifier is used to register and retrieve this overlay section.
   static const std::string SectionName;
 
protected:
   //! \brief Protected constructor
   //! \param de Reference to the display engine
   //!
   //! Creates a new time overlay section. This constructor is protected
   //! because instances should only be created through the creator class.
   DtOsgSensorViewTimeOverlaySection(makVrv::DtDe& de)
      : DtOsgSensorViewOverlaySection(de)
      , myText(0)
   {
   }
 
   //! \brief Text element displaying the simulation time
   //!
   //! Pointer to the text proxy object that renders the time text.
   //! This is created during initialization and updated during each update call.
   makVrv::DtTextProxy* myText;
};
 
//! \brief Factory class for creating time overlay sections
//!
//! DtOsgSensorViewTimeOverlaySectionCreator is responsible for creating
//! instances of DtOsgSensorViewTimeOverlaySection. It implements the
//! factory pattern, allowing the overlay system to create specialized sections
//! without knowing their implementation details.
class PLAYERSTATION_DLL DtOsgSensorViewTimeOverlaySectionCreator : public makVrv::DtOsgSensorViewOverlaySectionCreator
{
public:
   //! \brief Creates a new time overlay section
   //! \param de Reference to the display engine
   //! \return Pointer to the newly created overlay section
   //!
   //! Factory method that creates a new DtOsgSensorViewTimeOverlaySection
   //! instance with the specified display engine.
   virtual makVrv::DtOsgSensorViewOverlaySection* create(makVrv::DtDe& de) override
   {
      return new DtOsgSensorViewTimeOverlaySection(de);
   }
 
   //! \brief Creates a clone of this creator
   //! \return Pointer to a new instance of this creator
   //!
   //! Creates and returns a new instance of this creator class. This is used
   //! by the overlay system for creator registration and management.
   virtual makVrv::DtOsgSensorViewOverlaySectionCreator* clone() const override
   {
      return new DtOsgSensorViewTimeOverlaySectionCreator;
   }
};