vreBinocularsOverlay.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreBinocularsOverlay.h
//! \brief Component for displaying binoculars reticle overlay
//! \ingroup vreCommonComponents
 
#pragma once
 
#include "vreCommonComponents/export.h"
#include "vrePlayerStation/playerComponent.h"
 
#include "vreCommonComponents/qtQuickOverlay.h"
 
namespace makVrv
{
class DtDe;
class DtQuadProxy;
class DtChannelConfiguration;
class DtOsgChannel;
class DtChannel;
class DtChannelManager;
} // namespace makVrv
 
namespace makVre
{
//! \brief Type identifier for DtBinocularsOverlay component
constexpr const char* DtBinocularsOverlayType = "DtBinocularsOverlay";
 
//! \brief Component for rendering binoculars reticle overlay on the screen
//!
//! DtBinocularsOverlay provides a specialized overlay for binoculars view,
//! displaying reticle markings and managing post-processing effects.
//! It handles display visibility based on player state, equipment, and view mode.
//! The component supports both standard and VR viewing modes, automatically
//! adjusting reticle dimensions based on viewport and zoom settings.
class VRECOMMONCOMPONENTS_DLL DtBinocularsOverlay : public DtQtQuickOverlay
{
public:
   //! \brief Constructor for DtBinocularsOverlay
   //! \param className Class name for identification, defaults to "DtBinocularsOverlay"
   //!
   //! Initializes the component with default reticle settings
   DtBinocularsOverlay(const std::string& className = "DtBinocularsOverlay");
 
   //! \brief Virtual destructor for DtBinocularsOverlay
   virtual ~DtBinocularsOverlay() override;
 
   //! \brief Initializes the binoculars overlay component
   //! \param player Pointer to the player station this component belongs to
   //! \param config Configuration table containing overlay settings
   //! \return True if initialization succeeded, false otherwise
   //!
   //! Reads configuration values for reticle dimensions and sets up
   //! channel configuration change signals
   virtual bool initialize(makVre::DtPlayerStation* player, makVre::DtInitTable& config) override;
   //! \brief Performs post-initialization after all components are initialized
   //! \return True if post-initialization succeeded, false otherwise
   //!
   //! Sets up VR-specific configurations if applicable and initializes
   //! post-processing effect settings
   virtual bool postInitialize() override;
   //! \brief Called every frame to update the overlay state
   //! \param dt Delta time since the last frame in seconds
   //!
   //! Updates visibility and manages post-processing effects
   //! based on current overlay visibility state
   virtual void tick(double dt) override;
   //! \brief Shuts down the binoculars overlay component
   //!
   //! Disconnects signals and removes any post-processing effects
   virtual void shutdown() override;
 
   //! \brief Returns the type identifier for this component
   //! \return The type string for DtBinocularsOverlay
   virtual const char* type() const override;
 
   //! \brief Determines if the overlay should be visible
   //! \return True if the overlay should be visible, false otherwise
   //!
   //! Checks player status, health, posture, and equipment to decide
   //! if the binoculars overlay should be shown
   virtual bool isOverlayVisible();
 
   //! \brief Sets the height of the binoculars reticle
   //! \param height Height value for the reticle in screen units
   //!
   //! Updates the reticle height property in the QML overlay
   void setReticleHeight(float height);
 
   //! \brief Sets the visibility state of the overlay
   //! \param visible True to show the overlay, false to hide it
   //!
   //! Updates the visible property in the QML overlay
   void setVisible(bool visible);
 
protected:
   //! \brief Calculates the dimensions of the reticle based on current view settings
   //!
   //! Computes reticle size based on channel projection, viewport dimensions,
   //! and zoom settings, with special handling for VR mode
   virtual void computeReticleDimensions();
 
   //! \brief Slot called when a channel configuration is modified
   //! \param deName Name of the display engine
   //! \param winName Name of the window containing the channel
   //! \param oldChannelName Previous name of the channel
   //! \param config New channel configuration
   //!
   //! Recalculates reticle dimensions when channel configuration changes
   virtual void slot_channelConfigurationModified(const std::string& deName, const std::string& winName,
      const std::string& oldChannelName, const makVrv::DtChannelConfiguration& config);
 
   //! \brief Slot called when a channel is about to be destroyed
   //! \param channelManager Pointer to the channel manager
   //! \param channel Pointer to the channel being destroyed
   //!
   //! Clears the channel reference if our tracked channel is being destroyed
   virtual void slot_channelDestroyed(makVrv::DtChannelManager* channelManager, makVrv::DtChannel* channel);
 
   //! \brief Total size of the reticle in mils
   float myReticleTotalMils;
 
   //! \brief Flag indicating whether post-processing effects should be used
   bool myUsePostEffect;
 
   //! \brief Pointer to the channel used for rendering
   makVrv::DtOsgChannel* myChannel;
 
   //! \brief Cached configuration table for accessing settings during runtime
   makVre::DtInitTable myConfig;
};
} // namespace makVre