observerUpdater.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file observerUpdater.h
//! \brief Base component for managing observer parameters and view settings
//! \ingroup vreCommonComponents
 
#pragma once
 
#include "vreCommonComponents/export.h"
 
#include "vrePlayerStation/playerComponent.h"
 
#include <string>
#include <map>
 
namespace makVrv
{
class DtChannelConfiguration;
class DtWindow;
} // namespace makVrv
 
namespace ObserverUpdaterConfig
{
//! \ingroup RoleConfigParams
//! \defgroup ObserverUpdaterRoleParams Observer Updater Role Parameters
//! \roleInherits{PlayerComponentRoleParams}
//! Configuration Options for observer updater role.
//! @{
 
//! \vreRoleParam{horizontalFOV,double,45.0,observerUpdater,Horizontal field of view setting in degrees.}
constexpr const char* horizontalFOV = "horizontalFOV";
 
//! \vreRoleParam{verticalFOV,double,45.0,observerUpdater,Vertical field of view setting in degrees.}
constexpr const char* verticalFOV = "verticalFOV";
 
//! @}
} // namespace ObserverUpdaterConfig
 
//! \brief Structure representing a range of rotation values for observer movement
//!
//! Used to define the valid range of yaw and pitch angles for the observer,
//! stored in radians but typically configured in degrees
struct VRECOMMONCOMPONENTS_DLL ObserverRange
{
   //! \brief Default constructor
   ObserverRange() = default;
 
   //! \brief Sets the maximum value in the range, converting from degrees to radians
   //! \param m Maximum value in degrees
   void setMax(double m) { max = DtDeg2Rad(m); }
 
   //! \brief Sets the minimum value in the range, converting from degrees to radians
   //! \param m Minimum value in degrees
   void setMin(double m) { min = DtDeg2Rad(m); }
 
   //! \brief Maximum value of the range in radians
   double max;
 
   //! \brief Minimum value of the range in radians
   double min;
};
 
namespace makVre
{
class DtInitTable;
class DtPlayerStation;
class DtEntityResolver;
class DtInstrumentPanelManager;
 
//! \brief Type identifier for DtObserverUpdater component
constexpr const char* DtObserverUpdaterType = "DtObserverUpdater";
 
//! \brief Base component for managing observer view parameters and display settings
//!
//! DtObserverUpdater provides common functionality for managing observer view settings,
//! including field of view and view modes. It manages channel configurations
//! for windows and synchronizes sensor modes between VR-Engage and VR-Vantage.
//! This class serves as a base for more specialized observer updater components.
class VRECOMMONCOMPONENTS_DLL DtObserverUpdater : public DtPlayerComponent
{
public:
   //! \brief Default constructor for DtObserverUpdater
   //!
   //! Initializes the component with the default name "DtObserverUpdater"
   DtObserverUpdater();
 
   //! \brief Virtual destructor for DtObserverUpdater
   virtual ~DtObserverUpdater() override;
 
   //! \brief Initializes the observer updater component
   //! \param station Pointer to the player station this component belongs to
   //! \param config Configuration table containing observer settings
   //! \return True if initialization succeeded, false otherwise
   //!
   //! Sets up field of view parameters, and adds
   //! default channels to be managed by this component
   virtual bool initialize(DtPlayerStation* station, DtInitTable& config) override;
 
   //! \brief Performs post-initialization after all components are initialized
   //! \return True if post-initialization succeeded, false otherwise
   //!
   //! Sets up callbacks for sensor mode and observer mode changes
   virtual bool postInitialize() override;
 
   //! \brief Called every frame to update observer parameters
   //! \param dt Delta time since the last frame in seconds
   //!
   //! Updates all managed channels and player state attributes
   virtual void tick(double dt) override;
   //! \brief Shuts down the observer updater component
   //!
   //! Removes attribute callbacks and restores original channel settings
   virtual void shutdown() override;
 
   //! \brief Returns the component type identifier
   //! \return The component type string
   virtual const char* type() const override;
 
   //! \brief Adds a channel to be managed by this updater
   //! \param windowName Name of the window containing the channel
   //! \param channelName Name of the channel to add
   //!
   //! Stores the initial configuration of the channel and marks it for updates
   virtual void addChannelToUpdate(const std::string& windowName, const std::string& channelName);
 
   //! \brief Removes a channel from being managed by this updater
   //! \param windowName Name of the window containing the channel
   //! \param channelName Name of the channel to remove
   //! \param restoreInitialSettings If true, restores the channel's initial configuration
   //!
   //! Stops managing the specified channel and optionally restores its initial settings
   virtual void removeChannelToUpdate(
      const std::string& windowName, const std::string& channelName, bool restoreInitialSettings = true);
 
protected:
   //! \brief Initializes player state attributes related to observer settings
   //!
   //! Sets up field of view attributes and configures the initial channel projection
   virtual void initializeStateAttributes() override;
 
   //! \brief Handles changes to the sensor mode state attribute
   //! \param sensorMode New sensor mode value
   //!
   //! Updates the observer's sensor mode in VR-Vantage when the sensorMode attribute changes
   virtual void onSensorModeChanged(std::string sensorMode);
 
   //! \brief Handles changes to the observer mode state attribute
   //! \param observerMode New observer mode value
   //!
   //! Updates the observer's view mode in VR-Vantage when the observerMode attribute changes
   virtual void onObserverModeChanged(std::string observerMode);
 
   //! \brief Adds the default channel (Window 1, Channel 1) to be managed
   //!
   //! Adds the first window's Channel 1 to configurations to monitor.
   //! Derived classes can override this function to change this behavior.
   virtual void addDefaultChannels();
 
   //! \brief Adds VR-specific channels to be managed
   //!
   //! Adds HMD window channels for left and right eyes to be managed by this updater
   virtual void addVrChannels();
 
   //! \brief Finds the configuration for a specific channel
   //! \param windowName Name of the window containing the channel
   //! \param channelName Name of the channel to find
   //! \param config Output parameter that will receive the channel configuration
   //! \return True if the channel configuration was found, false otherwise
   //!
   //! Retrieves the current configuration of the specified channel
   virtual bool findChannelConfiguration(
      const std::string& windowName, const std::string& channelName, makVrv::DtChannelConfiguration& config);
 
   //! \brief Updates all managed channels with current settings
   //!
   //! Applies appropriate settings to all managed channels based on
   //! the display layout
   virtual void updateAllChannels();
 
   //! \brief Sets the showCockpits keyword on all managed channels
   //! \param show True to show cockpits, false to hide them
   //!
   //! Adds or removes the "showCockpits" keyword from channel configurations
   virtual void setShowCockpits(bool show);
 
   //! \brief Applies a configuration to a specific channel
   //! \param windowName Name of the window containing the channel
   //! \param channelName Name of the channel to configure
   //! \param newConfig New configuration to apply to the channel
   //! \return True if the configuration was successfully applied, false otherwise
   //!
   //! Modifies a channel's configuration through the window manager
   virtual bool applyConfigurationToChannel(
      const std::string& windowName, const std::string& channelName, const makVrv::DtChannelConfiguration& newConfig);
 
   //! \brief Gets the names of the first window and channel
   //! \param windowName Output parameter that will receive the window name
   //! \param channelName Output parameter that will receive the channel name
   //! \return True if a window and channel were found, false otherwise
   //!
   //! Finds and returns the names of the first window and its first channel
   bool firstWindowAndChannelNames(std::string& windowName, std::string& channelName);
 
   //! \brief Updates player state attributes with current observer data
   //!
   //! Updates position, orientation, and view attributes based on the current observer state
   virtual void updateStateAttributes();
 
   //! \brief Pointer to the instrument panel manager
   makVre::DtInstrumentPanelManager* myInstrumentPanelManager;
 
   //! \brief Type definition for window and channel name pairs
   using WindowAndChannelName = std::pair<std::string, std::string>;
 
   //! \brief Type definition for mapping window/channel pairs to configurations
   using ChannelConfigMap = std::map<WindowAndChannelName, makVrv::DtChannelConfiguration>;
 
   //! \brief Map of channel configurations to be updated
   //!
   //! Stores the initial configuration of each managed channel,
   //! keyed by window name and channel name pairs
   ChannelConfigMap myChannelsToUpdate;
 
   //! \brief Flag indicating if channel updates should be forced
   bool myForceChannelUpdate;
 
   //! \brief Vertical field of view in degrees
   double myVerticalFOV;
 
   //! \brief Horizontal field of view in degrees
   double myHorizontalFOV;
 
   //! \brief Pointer to the main window
   makVrv::DtWindow* myWindow;
};
 
} // namespace makVre