actionMenuUpdater.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file actionMenuUpdater.h
//! \brief Defines the action menu updating component for VR-Engage
//!
//! This file contains the DtActionMenuUpdater class which manages the updating
//! and rendering of action menus in VR-Engage. It handles initialization,
//! updating, and shutdown of menu displays, and coordinates with the menu system
//! to ensure proper visual presentation of menus.
 
#pragma once
 
#include "vrePlayerStation/export.h"
#include "vrePlayerStation/playerComponent.h"
 
#include <vreMessageManager/vreMessage.h>
#include <vreMessages/simulationState.h>
 
#include <vector>
 
namespace makVrv
{
class DtDe;
class DtQuadProxy;
class DtTextProxy;
class DtOverlayRenderer;
class DtOsgChannel;
class DtOsgWindow;
} // namespace makVrv
 
namespace makVre
{
namespace ActionMenuUpdaterConfig
{
//! \ingroup RoleConfigParams
//! \defgroup ActionMenuUpdaterRoleParams Action Menu Updater Role Parameters
//! \roleInherits{PlayerComponentRoleParams}
//! Configuration Options for action menu updater role.
//! @{
 
//! \vreRoleParam{inputMenus,table,{},actionMenuUpdater,Configuration table for input-specific menus and their properties.}
constexpr const char* inputMenus = "inputMenus";
 
//! \vreRoleParam{menus,table,{},actionMenuUpdater,Configuration table for general menus and their properties.}
constexpr const char* menus = "menus";
 
//! \vreRoleParam{vrPositionX,int,0,actionMenuUpdater,X coordinate position for VR menu display placement.}
constexpr const char* vrPositionX = "vrPositionX";
 
//! \vreRoleParam{vrPositionY,int,0,actionMenuUpdater,Y coordinate position for VR menu display placement.}
constexpr const char* vrPositionY = "vrPositionY";
 
//! @}
} // namespace ActionMenuUpdaterConfig
 
class DtMenuManager;
class DtQmlActionMenu;
 
//! \brief Type identifier constant for DtActionMenuUpdater components
//!
//! This constant defines the string identifier used to identify DtActionMenuUpdater
//! component types within the VR-Engage framework. It is used for component
//! registration, type checking, and serialization operations.
constexpr const char* DtActionMenuUpdaterType = "DtActionMenuUpdater";
 
//! \brief Component that manages action menu presentation and updates
//!
//! DtActionMenuUpdater is responsible for initializing, updating, and rendering
//! the action menus in VR-Engage. It coordinates with the menu system to ensure
//! proper visual presentation of menus, handles menu positioning, and responds
//! to changes in simulation state that affect menu content and visibility.
//!
//! This component works alongside DtActionMenuLogic, which handles the logical
//! aspects of menu behavior, while this class focuses on visual representation
//! and updating.
class PLAYERSTATION_DLL DtActionMenuUpdater : public DtPlayerComponent
{
public:
   //! \brief Constructor
   //!
   //! Creates a new action menu updater component with default state.
   DtActionMenuUpdater();
 
   //! \brief Virtual destructor
   //!
   //! Ensures proper cleanup of derived action menu updater classes.
   virtual ~DtActionMenuUpdater() override;
 
   //! \brief Initializes the action menu updater
   //! \param player Pointer to the owning player station
   //! \param config Configuration data for initialization
   //! \return True if initialization succeeded, false otherwise
   //!
   //! Sets up the action menu updater system based on the provided configuration.
   //! This includes creating a menu manager and initializing menu displays.
   virtual bool initialize(DtPlayerStation* player, DtInitTable& config) override;
 
   //! \brief Performs post-initialization setup
   //! \return True if post-initialization succeeded, false otherwise
   //!
   //! Completes setup tasks that need to occur after basic initialization,
   //! such as connecting to message handlers and initializing state attributes.
   virtual bool postInitialize() override;
 
   //! \brief Updates the menu displays
   //! \param dt Time interval since the last tick in seconds
   //!
   //! Called once per frame to update the visual representation of menus.
   //! This includes updating positions, visibility, and content based on
   //! the current simulation state.
   virtual void tick(double dt) override;
 
   //! \brief Shuts down the action menu updater
   //!
   //! Performs cleanup when the action menu updater is no longer needed.
   //! This includes destroying menu displays and disconnecting from message handlers.
   virtual void shutdown() override;
 
   //! \brief Returns the component type identifier
   //! \return String identifier for this component type
   //!
   //! Returns the type identifier string for this component, which is used
   //! by the VR-Engage framework for component identification and management.
   //! The returned value matches DtActionMenuUpdaterType.
   virtual const char* type() const override;
 
   //! \brief Initializes the menu system
   //! \param config Configuration data for menu initialization
   //! \return True if menu initialization succeeded, false otherwise
   //!
   //! Sets up the menu system based on the provided configuration data.
   //! This includes creating and configuring the menu manager and individual menus.
   virtual bool initializeMenus(DtInitTable& config);
 
   //! \brief Gets the QML action menu component
   //! \return Pointer to the QML action menu
   //!
   //! Provides access to the QML-based action menu for external use.
   //! This is useful for components that need to directly interact with
   //! the menu's visual representation.
   virtual DtQmlActionMenu* qmlActionMenu();
 
   //! \brief Reinitializes the quick menu system
   //!
   //! Rebuilds the quick menu system after changes that require a full
   //! reinitialization, such as configuration changes or mode switches.
   virtual void reinitializeQuick();
 
protected:
   //! \brief Initializes state attributes used by the menu system
   //!
   //! Sets up the state attributes needed for menu functionality, such as
   //! player state, entity state, and configuration attributes that affect menus.
   virtual void initializeStateAttributes() override;
 
   //! \brief Initializes the event menu
   //!
   //! Sets up the event menu, which displays event notifications and
   //! allows interaction with simulation events.
   virtual void initEventMenu();
 
   //! \brief Initializes the quick menu system
   //!
   //! Sets up the quick menu system for context-sensitive interactions.
   //! Quick menus appear when the player approaches interactive objects.
   virtual void initQuick();
 
   //! \brief Shuts down the quick menu system
   //!
   //! Cleans up resources used by the quick menu system when it's no longer needed.
   virtual void shutdownQuick();
 
   //! \brief Handles simulation state messages
   //! \param msg Pointer to the simulation state message
   //! \return Message handling result
   //!
   //! Processes simulation state updates that affect menu content and visibility,
   //! such as changes to deployable objects or player state.
   virtual makVre::DtVreMessageResult handleSimState(makVre::DtVreMessage* msg);
 
   //! \brief Handles application mode change messages
   //! \param msg Pointer to the application mode message
   //! \return Message handling result
   //!
   //! Processes changes in application mode that affect menu presentation,
   //! such as switching between 2D and VR modes or different UI layouts.
   virtual makVre::DtVreMessageResult handleApplicationMode(makVre::DtVreMessage* msg);
 
   //! \brief Pointer to the menu manager
   //!
   //! The menu manager that coordinates all menus for this player station instance.
   //! It handles the creation, organization, and display of menus.
   DtMenuManager* myMenuManager;
 
   //! \brief List of deployable objects available to the player
   //!
   //! Stores information about objects that can be deployed by the player,
   //! such as sensors, markers, or other equipment.
   std::vector<SimulationStateMessage::EmbeddedEntity> myDeployableObjects;
 
   //! \brief QML-based action menu component
   //!
   //! The QML implementation of the action menu used for rendering and interaction.
   //! QML provides a more modern and flexible UI compared to traditional approaches.
   DtQmlActionMenu* myQmlActionMenu;
 
   //! \brief Horizontal position for VR menu rendering
   //!
   //! The X-coordinate for positioning menus in VR mode.
   int myVrPositionX;
 
   //! \brief Vertical position for VR menu rendering
   //!
   //! The Y-coordinate for positioning menus in VR mode.
   int myVrPositionY;
};
} // namespace makVre