playerStationApp.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file playerStationApp.h
//! \brief Defines the DtPlayerStationApp class for the VR-Engage application
//!
//! This file contains the top-level application class for VR-Engage, which manages
//! player stations, components, plugins, and state transitions. It serves as the
//! central hub for coordination between different parts of the application and
//! provides access to various factories and managers.
 
#pragma once
 
#include "vrePlayerStation/export.h"
#include "vrePlayerStation/playerComponent.h"
#include "vrePlayerStation/connector.h"
#include "vrePlayerStation/playerCreationPalette.h"
 
#include "vreUtil/factory.h"
#include "vreUtil/initializer.h"
#include "vreUtil/attribute.h"
 
#include "vreMessageManager/vreMessage.h"
 
#include <vrvCore/DtUniqueID.h>
 
#include <vrvUtil/DtSignalConnectionManager.h>
 
#include <vlutil/vlMutex.h>
 
#include <map>
#include <string>
#include <vector>
#include <list>
#include <functional>
 
class DtSimulationAddress;
class DtFilename;
struct lua_State;
 
namespace makVrv
{
//! \brief Forward declaration of the display engine class
class DtDe;
 
//! \brief Forward declaration of the human command line processor class
class DtHumanCommandLineProcessor;
 
//! \brief Forward declaration of the observer class
class DtObserver;
 
//! \brief Forward declaration of the channel class
class DtChannel;
} // namespace makVrv
 
namespace makVre
{
//! \brief Forward declaration of the player station class
class DtPlayerStation;
 
//! \brief Forward declaration of the player station application class
class DtPlayerStationApp;
 
//! \brief Forward declaration of the time source class
class DtTimeSource;
 
//! \brief Forward declaration of the player configuration dialog class
class DtConfigurePlayerDialog;
 
//! \brief Forward declaration of the entity resolver class
class DtEntityResolver;
 
//! \brief Forward declaration of the status publisher class
class DtVreStatusPublisher;
 
//! \brief Forward declaration of the status listener class
class DtVreStatusListener;
 
//! \brief Forward declaration of the instrument panel manager class
class DtInstrumentPanelManager;
 
//! \brief Forward declaration of the input device factory class
class DtInputDeviceFactory;
 
//! \brief Forward declaration of the input manager class
class DtVreInputManager;
 
//! \brief Forward declaration of the observer mode mapper class
class DtVreObserverModeMapper;
 
//! \brief Forward declaration of the sensor mode mapper class
class DtVreSensorModeMapper;
 
//! \brief Forward declaration of the chat commands manager class
class DtChatCommandsManager;
 
//! \brief Forward declaration of the application input logic class
class DtPlayerStationAppInputLogic;
 
//! \brief Forward declaration of the input device class
class DtInputDevice;
 
// UI Classes
//! \brief Forward declaration of the role selection panel class
class DtChooseRolePanel;
 
//! \brief Forward declaration of the temporary notification class
class DtPlayerStationTempNotification;
 
// State Management
//! \brief Forward declaration of the state manager class
class DtPlayerStationStateManager;
 
//! \brief Type definitions for factory classes
//! @{
 
//! \brief Factory type for player components
using DtComponentFactory = DtFactory<DtPlayerComponent>;
 
//! \brief Factory type for connectors
using DtConnectorFactory = DtFactory<DtConnector>;
 
//! \brief Factory type for input devices
using DtDeviceFactory = DtFactory<DtInputDevice>;
//! @}
 
//! \brief Function pointer type for plugin initialization
//! \param app Pointer to the player station application
//! \return True if initialization was successful, false otherwise
//!
//! This function signature is used for plugin initialization functions that
//! are loaded dynamically from DLLs/shared libraries at runtime.
using InitPlayerStationDllFunction = bool (*)(DtPlayerStationApp* app);
 
//! \brief Enumeration of available sensor libraries for observer modes
//!
//! Defines which VR-Vantage sensor library is used for modeling different
//! observer sensor modes (e.g., IR, night vision).
using DtSensorLibrary = enum _DtSensorLibrary {
   CAMERA_FX = 0, //!< Uses the Camera FX library for visual effects
   SENSOR_FX      //!< Uses the Sensor FX library for visual effects
};
 
//! \brief Enumeration for dimensionality of the view
//!
//! Defines whether the view is 2D or 3D. Used in various parts of the
//! application to determine appropriate rendering modes and behaviors.
enum DtDimensionality
{
   Dt2D = 0, //!< 2D view (map/plan view)
   Dt3D      //!< 3D view (perspective view)
};
 
//! \brief Top-level class representing the VR-Engage application
//!
//! DtPlayerStationApp serves as the main coordinator for the VR-Engage application.
//! It manages player stations, component factories, state transitions, and provides
//! access to various application-wide services. This class is typically instantiated
//! once per application instance and accessible via the static instance() method.
class PLAYERSTATION_DLL DtPlayerStationApp
{
public:
   //! \brief Constructor
   //! \param de Reference to the VR-Vantage display engine
   //!
   //! Initializes the application with a reference to the display engine.
   //! Creates the component factories and prepares the application for initialization.
   DtPlayerStationApp(makVrv::DtDe& de);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources and performs final shutdown operations.
   virtual ~DtPlayerStationApp();
 
   //! \brief Gets the singleton instance of this class
   //! \return Pointer to the application instance, or NULL if not yet created
   //!
   //! Provides global access to the application instance. Returns NULL if the
   //! application has not yet been created. This is the preferred way to access
   //! the application instance from anywhere in the codebase.
   static DtPlayerStationApp* instance();
 
   //! \brief Initializes the application
   //!
   //! Reads configuration data from playerStation.lua and initializes all application
   //! subsystems, including the component factories, state manager, input manager,
   //! and default player stations if configured. This must be called before the
   //! application can be used.
   virtual void initialize();
 
   //! \brief Updates the application state
   //! \param dt Time in seconds since the previous tick
   //!
   //! This method should be called periodically (typically once per frame) to update
   //! the application state. It calls tick() on the top-level objects maintained by
   //! this class, including the player creation palette, state manager, input manager,
   //! and all active player stations. It also processes any deferred functions that
   //! are ready to execute.
   virtual void tick(double dt);
 
   //! \brief Shuts down the application
   //!
   //! Calls shutdown on all top-level objects maintained by the application,
   //! destroys all player stations, and releases resources. This should be
   //! called before the application is destroyed to ensure clean termination.
   virtual void shutdown();
 
   //! \brief Initiates application termination
   //!
   //! Called when the user closes the application main window. Sends a QCloseEvent
   //! which is handled at the VR-Vantage level, which eventually results in shutdown()
   //! being called. This provides a clean way to exit the application.
   virtual void quit();
 
   //! \brief Gets the name of the currently active VR-Engage station
   //! \return String containing the name of the active station
   //!
   //! Returns the name of the currently active VR-Engage station, as published by
   //! the DtVreStatusPublisher. Station names are defined in the player role files,
   //! such as "Pilot", "Human", "LAV Driver", etc.
   virtual std::string engageStationName();
 
   //! \brief Gets the unique identifier for this VR-Engage application instance
   //! \return Unique integer ID for this application instance
   //!
   //! Returns a unique identifier for this VR-Engage application instance, as published
   //! by the DtVreStatusPublisher. The ID is based on a hash of the initial station name
   //! and the process ID, ensuring uniqueness across multiple running instances.
   virtual unsigned long engageStationId();
 
   //! \brief Gets a reference to the VR-Vantage display engine
   //! \return Reference to the display engine
   //!
   //! Provides access to the VR-Vantage display engine, which is valid over the
   //! lifetime of the application. The display engine is used for rendering and
   //! managing the visual components of the application.
   virtual makVrv::DtDe& de();
 
   //! \brief Gets the application initializer
   //! \return Reference to the initializer instance
   //!
   //! The initializer is responsible for loading the Lua configuration files used to
   //! initialize the application. It holds the configuration data defined in
   //! appData\scripts\playerStation.lua, which is used throughout the application
   //! to configure components, connectors, and application behavior.
   virtual DtInitializer& initializer();
 
   //! \brief Gets the startup configuration data
   //! \return Table of startup configuration data
   //!
   //! Returns the configuration data for the startupConfiguration table in playerStation.lua.
   //! This includes settings such as default observer modes, window positions, and
   //! initial application state.
   virtual DtInitTable startupConfig();
 
   //! \brief Finds a named initialization table
   //! \param name Name of the table to find
   //! \return The initialization table with the given name, or an empty table if not found
   //!
   //! Looks up a table data member corresponding to a Lua table entry in playerStation.lua.
   //! This provides access to specific configuration sections without having to navigate
   //! through the entire configuration hierarchy.
   virtual DtInitTable findInitTable(const std::string& name);
 
   //! \brief Gets the player creation palette
   //! \return Reference to the player creation palette
   //!
   //! Returns the palette of VR-Engagable entities that can be created. The palette
   //! contains information about available player roles and their configurations.
   //! This reference is valid for the lifetime of the application.
   virtual DtPlayerCreationPalette& playerCreationPalette();
 
   //! \brief Gets the role selection panel
   //! \return Pointer to the choose role panel
   //!
   //! Returns the window containing the creation palette and controls for configuring
   //! player roles. This panel is used to select and configure new player stations.
   virtual DtChooseRolePanel* getChoosePlayerPanel();
 
   //! \brief Gets the current sensor library
   //! \return The sensor library currently in use (CAMERA_FX or SENSOR_FX)
   //!
   //! Returns the sensor library currently in use for the application, which determines
   //! how visual effects like night vision and thermal imaging are rendered.
   virtual DtSensorLibrary sensorLibrary() const;
 
   //! \brief Checks if the application window is being dragged
   //! \return True if the window is being dragged, false otherwise
   //!
   //! Determines whether the application window is currently being dragged
   //! in the display, which may affect input handling and rendering.
   virtual bool isDragging();
   //! \brief Sets the dragging state of the application window
   //! \param dragging True to indicate dragging is active, false otherwise
   //!
   //! Updates the internal state that tracks whether the application window
   //! is currently being dragged in the display.
   virtual void setIsDragging(bool dragging);
 
   //! \brief Gets the component factory
   //! \return Reference to the component factory
   //!
   //! Returns the factory for creating DtComponent class objects. Components
   //! are the building blocks that make up a player role, providing specific
   //! functionality such as movement, weapons, and sensors.
   virtual DtComponentFactory& componentFactory();
 
   //! \brief Gets the connector factory
   //! \return Reference to the connector factory
   //!
   //! Returns the factory for creating DtConnector class objects. Connectors
   //! handle communication between the application and external systems or
   //! simulation entities.
   virtual DtConnectorFactory& connectorFactory();
 
   //! \brief Gets the input device factory
   //! \return Pointer to the input device factory
   //!
   //! Returns the factory for creating DtInputDevice class objects. Input devices
   //! handle user interaction through various peripherals like keyboards, mice,
   //! joysticks, and other specialized hardware.
   virtual DtInputDeviceFactory* inputDeviceFactory();
 
   //! \brief Creates a new player station with default settings
   //! \return Pointer to the newly created player station
   //!
   //! Factory function that returns a new instance of a DtPlayerStation with
   //! default settings. The created station is owned by the application and
   //! will be destroyed when the application shuts down.
   virtual DtPlayerStation* createPlayerStation();
 
   //! \brief Creates a new player station with specific settings
   //! \param id The SISO entity identifier of the entity to be created
   //! \param station The name of the station to create
   //! \param displayLayout The name of the display layout to use
   //! \return Pointer to the newly created player station
   //!
   //! Factory function that returns a new instance of a DtPlayerStation with
   //! the specified entity ID, station type, and display layout. The created
   //! station is owned by the application and will be destroyed when the
   //! application shuts down.
   virtual DtPlayerStation* createPlayerStation(
      const DtEntityIdentifier& id, const std::string& station, const std::string& displayLayout);
 
   //! \brief Destroys all player stations
   //! \return True if any player stations were destroyed, false otherwise
   //!
   //! Removes and destroys all active player stations, freeing their resources.
   virtual bool destroyPlayerStation();
 
   //! \brief Destroys a specific player station by entity identifier
   //! \param entityId The entity identifier of the player station to destroy
   //! \return True if the player station was found and destroyed, false otherwise
   //!
   //! Removes and destroys a player station with the specified entity identifier.
   virtual bool destroyPlayerStation(const DtEntityIdentifier&);
 
   //! \brief Destroys a specific player station by entity identifier and station name
   //! \param entityId The entity identifier of the player station to destroy
   //! \param stationName The name of the station to destroy
   //! \return True if the player station was found and destroyed, false otherwise
   //!
   //! Removes and destroys a player station matching both the specified entity identifier and station name.
   virtual bool destroyPlayerStation(const DtEntityIdentifier&, const std::string& stationName);
 
   //! \brief Finds a player station by entity identifier and station name
   //! \param entityId The entity identifier to search for
   //! \param stationName The station name to search for
   //! \return Pointer to the found player station, or NULL if not found
   //!
   //! Searches for a player station that matches both the specified entity identifier and station name.
   virtual DtPlayerStation* findPlayerStation(const DtEntityIdentifier&, const std::string& stationName);
 
   //! \brief Finds the first player station in the list
   //! \return Pointer to the first player station, or NULL if none exist
   //!
   //! Returns the first player station in the player list. Used as a convenience method
   //! when the application only has a single player station.
   virtual DtPlayerStation* findPlayer();
   //! \brief Finds a player station at a specific index
   //! \param index The index in the player list
   //! \return Pointer to the player station at the specified index, or NULL if index is out of range
   //!
   //! Returns the player station at the specified index in the player list.
   virtual DtPlayerStation* findPlayerAt(int index);
   //! \brief Finds a player station by entity identifier
   //! \param entityId The entity identifier to search for
   //! \return Pointer to the found player station, or NULL if not found
   //!
   //! Searches for a player station with the specified entity identifier.
   virtual DtPlayerStation* findPlayer(const DtEntityIdentifier&);
   //! \brief Finds a player station by element ID
   //! \param elementId The VR-Vantage element ID to search for
   //! \return Pointer to the found player station, or NULL if not found
   //!
   //! Searches for a player station with the specified VR-Vantage element ID.
   virtual DtPlayerStation* findPlayer(makVrv::DtElementID);
   //! \brief Gets the list of all player stations
   //! \return Reference to the list of player stations
   //!
   //! Returns a reference to the internal list of all active player stations.
   //! This list is valid for the duration of the application.
   virtual std::list<DtPlayerStation*>& players();
   //! \brief Removes all player stations from the list without destroying them
   //!
   //! Clears the internal player stations list without destroying the player station objects.
   //! This is typically used during cleanup operations.
   virtual void clearPlayers();
   //! \brief Sets the entity to which the observer is attached
   //! \param entityId The entity identifier to attach to
   //!
   //! Updates the entity to which the primary observer is attached.
   //! When attached, the observer will follow this entity's movements.
   virtual void setAttachEntity(DtEntityIdentifier const& entityId);
   //! \brief Gets the entity to which the observer is currently attached
   //! \return The entity identifier of the attached entity
   //!
   //! Returns the identifier of the entity to which the primary observer is currently attached.
   //! Returns an invalid identifier if the observer is not attached to any entity.
   virtual DtEntityIdentifier getAttachEntity();
 
   //! \brief Detaches the observer if it is attached to the specified element
   //! \param elementId The element ID to check
   //!
   //! If the observer is attached to the given element ID, this method detaches it,
   //! allowing free movement of the observer. This is typically called when an entity
   //! is about to be removed from the simulation.
   virtual void detatchObserverIfAttachedTo(makVrv::DtElementID);
 
   //! \brief Centers the observer on the terrain
   //!
   //! Positions the primary observer over the center of the terrain
   //! at a predefined height. This is typically used to get a broad overview
   //! of the simulation area.
   virtual void centerObserverOnTerrain();
 
   //! \brief Makes the observer look at multiple entities
   //! \param entityIds Vector of entity identifiers to look at
   //!
   //! Positions and orients the primary observer to view all of the specified entities.
   //! The observer will be positioned to keep all entities in view.
   virtual void observerLookAt(const std::vector<DtEntityIdentifier>&);
 
   //! \brief Makes the observer look at a single entity
   //! \param entityId Entity identifier to look at
   //!
   //! Positions and orients the primary observer to view the specified entity.
   //! The observer's position is adjusted to provide a good view of the entity.
   virtual void observerLookAt(const DtEntityIdentifier&);
 
   //! \brief Makes the observer follow an entity
   //! \param entityId Entity identifier to follow
   //!
   //! Attaches the primary observer to the specified entity, causing it to
   //! follow the entity's movements while maintaining a fixed relative position.
   virtual void observerFollow(const DtEntityIdentifier&);
 
   //! \brief Detaches the observer from any entity it may be following
   //!
   //! Releases the primary observer from attachment to any entity,
   //! allowing it to be moved independently.
   virtual void observerDetach();
   //! \brief Checks if the observer has a default position
   //! \param outName Optional parameter to receive the name of the default position
   //! \return True if a default position exists, false otherwise
   //!
   //! Determines whether a default position has been defined for the primary observer.
   //! If outName is provided, it will be filled with the name of the default position.
   virtual bool observerHasDefault(std::string* outName = NULL);
 
   //! \brief Resets the observer to its default position
   //!
   //! Returns the primary observer to its default position and orientation.
   //! If no default has been set, this may place the observer at a predefined location.
   virtual void observerReset();
 
   //! \brief Resets the view in the Choose Role panel
   //!
   //! If the Choose Role Panel is visible, calls slot_onResetViewClicked()
   //! to reset the view to its default state. This is typically used to
   //! return to the initial view when selecting a role.
   virtual void resetView();
 
   //! \brief Gets the name of the application-level observer
   //! \return String containing the name of the primary observer
   //!
   //! Returns the name of the application-level observer, which is typically "Observer 1".
   //! This is the primary observer used for the main view in the application.
   virtual std::string observerName() const;
 
   //! \brief Gets the status listener
   //! \return Pointer to the status listener
   //!
   //! Returns the status listener, which monitors status messages from all
   //! VR-Engage player stations and maintains a list of active stations
   //! and the entities they are engaged with.
   virtual DtVreStatusListener* statusListener() const;
 
   //! \brief Sets the current player station type name
   //! \param playerType The name of the player station type
   //!
   //! Sets the type name for the current player station, such as "Pilot",
   //! "Human", "Vehicle Driver", etc. This name is used to identify
   //! the station type in the UI and in status messages.
   virtual void setPlayerStationName(const std::string& playerType);
 
   //! \brief Sets the display layout for the current player station
   //! \param displayLayout The name of the display layout to use
   //!
   //! Sets the display layout for the current player station. The display layout
   //! defines how the UI is arranged, including panels, controls, and views.
   virtual void setPlayerStationDisplayLayout(const std::string& displayLayout);
 
   //! \brief Gets the current player station type name
   //! \return Constant reference to the player station type name string
   //!
   //! Returns the type name of the current player station, such as "Pilot",
   //! "Human", "Vehicle Driver", etc.
   virtual std::string const& getPlayerStationName() const;
 
   //! \brief Gets the current player station display layout
   //! \return Constant reference to the display layout name string
   //!
   //! Returns the name of the display layout currently in use by the player station.
   virtual std::string const& getPlayerStationDisplayLayout() const;
 
   //! \brief Runs the simulation
   //!
   //! Starts or resumes the simulation from its current state. This method
   //! sends messages to connected systems to synchronize the simulation state.
   virtual void run();
 
   //! \brief Pauses the simulation
   //!
   //! Pauses the simulation, freezing all simulation time and dynamics updates
   //! while maintaining the current state. This method sends messages to
   //! connected systems to synchronize the pause state.
   virtual void pause();
 
   //! \brief Rewinds the simulation
   //!
   //! Rewinds the simulation to its initial state. This is typically used
   //! in recorded or scenario playback modes to restart from the beginning.
   //! This method sends messages to connected systems to synchronize the rewind.
   virtual void rewind();
 
   //! \brief Sets the play fullscreen mode
   //! \param fullscreen True to enable fullscreen mode, false to disable it
   //!
   //! Controls whether the application should use the full screen when in play mode.
   //! This affects how the application displays when transitioning to engaged state.
   virtual void setPlayFullScreen(bool fullscreen);
 
   //! \brief Gets the play fullscreen mode setting
   //! \return True if play fullscreen mode is enabled, false otherwise
   //!
   //! Returns whether the application is configured to use the full screen when in play mode.
   virtual bool getPlayFullScreen();
 
   //! \brief Sets the application's fullscreen state
   //! \param fullscreen True to enable fullscreen mode, false to disable it
   //!
   //! Immediately changes the application between fullscreen and windowed mode.
   //! This affects the current display mode regardless of application state.
   virtual void setFullScreen(bool fullscreen);
 
   //! \brief Checks if the application is currently in fullscreen mode
   //! \return True if the application is fullscreen, false if it's windowed
   //!
   //! Returns whether the application is currently displayed in fullscreen mode.
   virtual bool isFullScreen();
 
   //! \brief Sets the current mode of the application
   //! \param mode The application mode to set (e.g., "Admin", "Player")
   //! \param changeMenus Whether to update the menus based on the new mode (default: true)
   //! \param isInitialSet Whether this is the initial setting of the mode (default: false)
   //! \return True if the mode was successfully set, false otherwise
   //!
   //! Changes the current application mode, which affects available features and UI elements.
   //! Different modes provide different access levels and functionality.
   virtual bool setAppMode(const std::string& mode, bool changeMenus = true, bool isInitialSet = false);
 
   //! \brief Gets the current application mode
   //! \return Constant reference to the current application mode string
   //!
   //! Returns the current operating mode of the application, such as "Admin" or "Player".
   virtual std::string const& getAppMode() const;
 
   //! \brief Toggles between available application modes
   //!
   //! Switches the application between available modes, typically toggling
   //! between "Admin" and "Player" modes. This affects the available
   //! features and UI elements.
   virtual void toggleAppMode();
 
   //! \brief Updates the application menus based on the specified mode
   //! \param appMode The application mode to update menus for
   //!
   //! Updates the application menu structure and visibility based on the
   //! specified application mode. Different modes have different menu options available.
   virtual void updateMenus(const std::string& appMode);
 
   //! \brief Enables or disables admin mode
   //! \param enabled True to enable admin mode, false to disable it
   //!
   //! Controls whether administrative features are available in the application.
   //! Admin mode provides access to additional configuration and debug options.
   virtual void setAdminModeEnabled(bool enabled);
 
   //! \brief Checks if admin mode is enabled
   //! \return True if admin mode is enabled, false otherwise
   //!
   //! Determines whether the application currently has administrative features enabled.
   virtual bool isAdminModeEnabled();
 
   //! \brief Spectator mode functions
   //! @{
 
   //! \brief Checks if spectator mode is active
   //! \return True if spectator mode is enabled, false otherwise
   //!
   //! Determines whether the application is in spectator mode, which blocks
   //! all input except view controls, allowing passive observation only.
   virtual bool isSpectator();
 
   //! \brief Sets spectator mode state
   //! \param value True to enable spectator mode, false to disable it
   //!
   //! Enables or disables spectator mode, which blocks all input except view
   //! controls when enabled, allowing passive observation only.
   virtual void setSpectator(bool value);
   //! @}
 
   //! \brief Role mode functions
   //! @{
 
   //! \brief Checks if fixed role mode is enabled
   //! \return True if fixed role mode is enabled, false otherwise
   //!
   //! Determines whether the application is in fixed role mode, which restricts
   //! the user to a predetermined role rather than allowing role selection.
   virtual bool fixedRoleMode();
 
   //! \brief Sets the fixed role mode state
   //! \param on True to enable fixed role mode, false to disable it
   //!
   //! Controls whether the application uses a fixed, predetermined role
   //! rather than allowing the user to select from available roles.
   virtual void setFixedRole(bool on = true);
   //! @}
 
   //! \brief Checks if VR support is available
   //! \return True if virtual reality is available, false otherwise
   //!
   //! Determines whether VR hardware and software support is available
   //! in the current runtime environment.
   virtual bool virtualRealityAvailable();
 
   //! \brief Checks if VRV controls are enabled
   //! \return True if VRV controls are enabled, false otherwise
   //!
   //! Determines whether VR-Vantage specific controls are currently enabled
   //! in the application interface.
   virtual bool isVRVControlsEnabled();
 
   //! \brief Checks if the 3D role selection panel is enabled
   //! \return True if the 3D panel is enabled, false if using 2D panel
   //!
   //! Determines whether the application is using a 3D or 2D version of
   //! the role selection panel interface.
   virtual bool isChooseRolePanel3D();
 
   //! \brief Gets the application state manager
   //! \return Reference to the state manager
   //!
   //! Provides access to the state manager, which controls application
   //! state transitions and maintains the state stack.
   virtual DtPlayerStationStateManager& stateManager();
 
   //! \brief Gets the input manager
   //! \return Reference to the input manager
   //!
   //! Provides access to the input manager, which handles user input
   //! from various devices and dispatches input events.
   virtual DtVreInputManager& inputManager();
 
   //! \brief Gets the chat command manager
   //! \return Reference to the chat command manager
   //!
   //! Provides access to the chat command manager, which handles
   //! processing and execution of text commands in the chat interface.
   virtual DtChatCommandsManager& chatCommandManager();
 
   //! \brief Checks if an entity type is allowed
   //! \param entityType The entity type to check
   //! \return True if the entity type is allowed, false otherwise
   //!
   //! Determines whether the specified entity type is allowed to be
   //! created or used in the current application configuration.
   bool isTypeAllowed(DtEntityType entityType);
 
   //! \brief Sets the observer mode for play state
   //! \return True if the observer mode was set successfully, false otherwise
   //!
   //! Configures the observer mode that will be used when in the play state,
   //! based on the current sensor library configuration.
   virtual bool setPlayStateObserverMode();
 
   //! \brief Sets the observer mode for non-play states
   //! \param dimensionality Specifies whether to use 2D or 3D mode
   //! \return True if the observer mode was set successfully, false otherwise
   //!
   //! Configures the observer mode that will be used when in non-play states
   //! (such as role selection), based on the specified dimensionality and
   //! the current sensor library configuration.
   virtual bool setNonPlayStateObserverMode(enum DtDimensionality dimensionality);
 
   //! \brief Gets the observer mode mapper
   //! \return Pointer to the observer mode mapper
   //!
   //! Returns the utility class used to map generic VR-Engage observer mode names
   //! to concrete VR-Vantage observer mode names, based on the current sensor library.
   //! The mappings used by this class are defined in vreObserverModeMapper in playerStation.lua.
   virtual DtVreObserverModeMapper* vreObserverModeMapper() const;
 
   //! \brief Gets the sensor mode mapper
   //! \return Pointer to the sensor mode mapper
   //!
   //! Returns the utility class used to map generic VR-Engage sensor mode names
   //! to concrete VR-Vantage sensor mode names, based on the current sensor library.
   //! The mappings used by this class are defined in vreSensorModeMapper in playerStation.lua.
   virtual DtVreSensorModeMapper* vreSensorModeMapper() const;
 
   //! \brief Gets the temporary notification handler
   //! \return Pointer to the temporary notification handler
   //!
   //! Returns the handler for showing temporary notifications in the UI.
   virtual DtPlayerStationTempNotification* tempNotification() { return myTempNotification; };
 
   //! \brief Increments the active HUD texture count
   //! \param textureID ID of the texture to increment
   //! \return Current count after incrementing
   //!
   //! Increases the reference count for a HUD texture and returns the new count.
   int incrementActiveHudTexture(int textureID);
 
   //! \brief Decrements the active HUD texture count
   //! \param textureID ID of the texture to decrement
   //! \return Current count after decrementing
   //!
   //! Decreases the reference count for a HUD texture and returns the new count.
   int decrementActiveHudTexture(int textureID);
 
   //! \brief Gets the current HUD texture count
   //! \param textureID ID of the texture to query
   //! \return Current reference count for the texture
   //!
   //! Returns the current reference count for a specific HUD texture ID.
   int getActiveHudTextureCount(int textureID);
 
   //! \brief Air mode functions
   //! @{
 
   //! \brief Checks if air mode is enabled
   //! \param b Optional parameter to check alternate state
   //! \return True if air mode is enabled, false otherwise
   static bool isAirEnabled(bool b = false);
 
   //! \brief Checks if air-only mode is active
   //! \return True if only air mode is enabled, false otherwise
   static bool isAirOnly();
   //! @}
 
   //! \brief Ground mode functions
   //! @{
 
   //! \brief Checks if ground mode is enabled
   //! \param b Optional parameter to check alternate state
   //! \return True if ground mode is enabled, false otherwise
   static bool isGroundEnabled(bool b = false);
 
   //! \brief Checks if ground-only mode is active
   //! \return True if only ground mode is enabled, false otherwise
   static bool isGroundOnly();
   //! @}
 
   //! \brief Sensor mode functions
   //! @{
 
   //! \brief Checks if sensor mode is enabled
   //! \param b Optional parameter to check alternate state
   //! \return True if sensor mode is enabled, false otherwise
   static bool isSensorEnabled(bool b = false);
 
   //! \brief Checks if sensor-only mode is active
   //! \return True if only sensor mode is enabled, false otherwise
   static bool isSensorOnly();
   //! @}
 
   //! \brief Checks if combined mode is active
   //! \return True if combined mode is active, false otherwise
   //!
   //! Determines whether the application is in combined mode,
   //! which allows multiple role types simultaneously.
   static bool isCombinedMode();
 
   //! \brief Gets the application name
   //! \return String containing the application name
   //!
   //! Returns the application name, used by the network forwarder
   //! to identify this application for RequestSubscribeMessage events.
   virtual std::string applicationName();
 
   //! \brief Signal for menu bar visibility changes
   boost::signalslib::signal<void()> signal_menuBarVisibilityChanged;
 
   //! \brief Checks if the menu bar is visible
   //! \return True if the menu bar is visible, false otherwise
   //!
   //! Determines whether the application menu bar is currently visible.
   virtual bool isMenuBarVisible() const;
 
   //! \brief Checks if ImGui is visible
   //! \return True if ImGui is visible, false otherwise
   //!
   //! Determines whether ImGui debug interface is currently visible.
   bool isImguiVisible();
 
   //! \brief Gets the application attribute store
   //! \return Handle to the application attribute store
   //!
   //! Provides access to the application's attribute store, which
   //! contains shared application data.
   DtAttributeHandle appAttributeStore();
 
   //! \brief Gets the application attribute store (const version)
   //! \return Const handle to the application attribute store
   const DtAttributeHandle appAttributeStore() const;
 
   //! \brief Defers a function to be executed after a number of ticks
   //! \param f Function to execute
   //! \param delayInTicks Number of ticks to wait before execution (default: 0)
   //!
   //! Schedules a function to be executed after the specified number of ticks.
   void deferFunction(std::function<void()>& f, int delayInTicks = 0);
 
   //! \brief Defers a function to be executed after a time delay
   //! \param f Function to execute
   //! \param delayInSeconds Seconds to wait before execution
   //!
   //! Schedules a function to be executed after the specified time delay in seconds.
   void deferFunction(std::function<void()>& f, double delayInSeconds);
 
protected:
   //! \brief Sets the observer mode for the primary observer
   //! \param name Name of the observer mode to set
   //! \return Pointer to the observer, or NULL if not found
   //!
   //! Sets the observer mode for "Observer 1", the main application observer.
   virtual makVrv::DtObserver* setObserverMode(const std::string& name);
 
   //! \brief Gets the path to the plugin directory
   //! \return String containing the plugin directory path
   //!
   //! Returns the full path to the directory containing VR-Engage plugins.
   //! Plugins are loaded from this directory during application initialization.
   virtual std::string pluginPath() const;
 
   //! \brief Loads a VR-Engage DLL plugin
   //! \param filename Name of the DLL file to load
   //! \return True if the DLL was loaded successfully, false otherwise
   //!
   //! Attempts to load a plugin DLL and initialize it by calling its entry point function.
   //! The initialization function is expected to have the signature defined by
   //! InitPlayerStationDllFunction.
   virtual bool loadVreDll(const std::string& filename);
 
   //! \brief Loads all plugins in the plugin directory
   //!
   //! Scans the plugin directory for DLL files and attempts to load each one
   //! as a VR-Engage plugin. Successfully loaded plugins will be initialized
   //! during this process.
   virtual void loadPlugins();
 
   //! \brief Finds the main rendering channel
   //!
   //! Locates and stores a reference to the main rendering channel used by
   //! the application. The main rendering channel is responsible for the
   //! primary visualization window.
   virtual void findMainRenderChannel();
 
   //! \brief Updates the status publisher with current state
   //!
   //! Updates the status publisher with the current application state,
   //! including active player stations and their entities. This information
   //! is broadcast to other components in the distributed simulation.
   virtual void updateStatusPublisher();
 
   //! \brief Initializes the status publisher
   //!
   //! Creates and configures the status publisher, which is responsible for
   //! broadcasting the state of the VR-Engage application and its player
   //! stations to other components in the distributed simulation.
   void initStatusPublisher();
 
   //! \brief Initializes the status listener
   //!
   //! Creates and configures the status listener, which monitors status
   //! messages from other VR-Engage instances and maintains a list of active
   //! stations and the entities they are engaged with.
   void initStatusListener();
 
   //! \brief Initializes virtual reality support
   //!
   //! Sets up the virtual reality subsystem if VR hardware is available.
   //! This includes initializing the VR drivers and configuring the display
   //! settings for VR mode.
   void initVirtualReality();
 
   //! \brief Initializes the minion monitor
   //!
   //! Sets up the monitoring system for minion mode operation. In minion mode,
   //! this instance of VR-Engage follows the state of a "boss" instance and
   //! automatically synchronizes with its actions.
   void initMinionMonitor();
 
   //! \brief Monitors the status of the boss station in minion mode
   //! \param message The status message to process
   //! \return Message result indicating how the message was handled
   //!
   //! If this station is configured to run in minion mode, this function
   //! is registered as a handler of VreStatusMessage messages to
   //! monitor the status of the boss station and match whatever entity
   //! the boss station is engaged with.
   DtVreMessageResult minionModeBossMonitor(DtVreMessage* message);
 
   //! \brief Requests the boss station to forward messages
   //! \param message The subscription request message
   //! \return Message result indicating how the message was handled
   //!
   //! If this station is in minion mode, requests the boss station to
   //! forward messages of the specified type to this station.
   DtVreMessageResult handleSubscribeToBoss(DtVreMessage* message);
 
   //! \brief Requests the boss station to stop forwarding messages
   //! \param message The unsubscription request message
   //! \return Message result indicating how the message was handled
   //!
   //! If this station is in minion mode, requests the boss station to
   //! stop forwarding messages of the specified type to this station.
   DtVreMessageResult handleUnsubscribeFromBoss(DtVreMessage* message);
 
   //! \brief Handles session SMS list messages
   //! \param message The session SMS list message
   //! \return Message result indicating how the message was handled
   //!
   //! Processes messages containing the list of simulation model sets (SMS)
   //! available in the current session.
   DtVreMessageResult handleSessionSmsListMessage(DtVreMessage* message);
 
protected:
   //! \brief Single instance of the application
   //!
   //! Static pointer to the singleton instance of the application. Used by the
   //! static instance() method to provide global access to the application.
   static DtPlayerStationApp* theApp;
 
   //! \brief Temporary notification handler
   //!
   DtPlayerStationTempNotification* myTempNotification;
 
   //! \brief Initializers and configuration
   //! @{
 
   //! \brief Lua configuration initializer
   //!
   //! Responsible for loading and parsing Lua configuration files.
   DtInitializer* myInitializer;
 
   //! \brief Startup configuration table
   //!
   //! Contains the startup configuration data from playerStation.lua.
   DtInitTable myStartupConfig;
 
   //! \brief Minion mode configuration table
   //!
   //! Contains configuration data for minion mode operation.
   DtInitTable myMinionConfig;
 
   //! \brief Entity resolver
   //!
   //! Resolves entity identifiers to entity instances.
   DtEntityResolver* myEntityResolver;
   //! @}
 
   //! \brief Application managers
   //! @{
 
   //! \brief Instrument panel manager
   //!
   //! Manages the creation and arrangement of instrument panels in the UI.
   DtInstrumentPanelManager* myInstrumentPanelManager;
 
   //! \brief Signal connection manager
   //!
   //! Manages signal connections between components in the application.
   makVrv::DtSignalConnectionManager myConnections;
 
   //! \brief State manager
   //!
   //! Manages application state transitions and maintains the state stack.
   DtPlayerStationStateManager* myStateManager;
 
   //! \brief Input manager
   //!
   //! Handles user input from various devices and dispatches input events.
   DtVreInputManager* myInputManager;
 
   //! \brief Input logic handler
   //!
   //! Implements application-specific input handling logic.
   DtPlayerStationAppInputLogic* myInputLogic;
   //! @}
 
   //! \brief Factory objects
   //! @{
 
   //! \brief Component factory
   //!
   //! Creates player component instances based on registered component classes.
   DtComponentFactory myComponentFactory;
 
   //! \brief Connector factory
   //!
   //! Creates connector instances based on registered connector classes.
   DtConnectorFactory myConnectorFactory;
 
   //! \brief Input device factory
   //!
   //! Creates input device instances based on registered device classes.
   DtInputDeviceFactory* myInputDeviceFactory;
   //! @}
 
   //! \brief Chat commands manager
   //!
   //! Manages the processing and execution of text commands in the chat interface.
   std::shared_ptr<DtChatCommandsManager> myChatCommandManager;
 
   //! \brief List of active player stations
   //!
   //! Contains pointers to all active player stations managed by the application.
   //! This list is used for managing embarkation and assumptions are made
   //! that this list represents an embarkation stack.
   std::list<DtPlayerStation*> myPlayers;
 
   //! \brief Menu bar visibility state
   //!
   //! Tracks whether the application menu bar is currently visible.
   bool myMenuBarVisible;
 
   //! \brief Full screen mode state for play mode
   //!
   //! Controls whether the application uses the full screen when in play mode.
   bool myPlayFullScreen;
 
   //! \brief Spectator mode state
   //!
   //! When true, blocks all input except view controls. Spectator mode allows
   //! passive observation of the simulation without player interaction.
   bool myAmSpectator;
 
   //! \brief Entity identifier for the owned entity
   //!
   //! The identifier for the application's primary entity. The application
   //! is allowed to create only one own entity.
   DtEntityIdentifier myOwnEntityId;
 
   //! \brief Resource mutex
   //!
   //! Protects shared resources from concurrent access.
   DtMutex myResourceMutex;
 
   //! \brief Reference to the VR-Vantage display engine
   //!
   //! Provides access to the rendering engine and window management.
   makVrv::DtDe& myDe;
 
   //! \brief Current player station type name
   //!
   //! The type name of the current player station, such as "Pilot" or "Vehicle Driver".
   std::string myPlayerStationName;
 
   //! \brief Current display layout name
   //!
   //! The name of the display layout currently in use by the player station.
   std::string myPlayerStationDisplayLayout;
 
   //! \brief Admin mode variables
   //! @{
 
   //! \brief Current application mode
   //!
   //! The current operating mode of the application, such as "Admin" or "Player".
   std::string myAppMode;
 
   //! \brief Previous application mode
   //!
   //! Stores the previous application mode, used when toggling between modes.
   std::string myOldAppMode;
 
   //! \brief Admin mode enabled state
   //!
   //! Controls whether administrative features are available in the application.
   bool myAdminModeEnabled;
   //! @}
 
   //! \brief Debug mode state
   //!
   //! When true, enables additional debug output and functionality.
   bool myDebugMode;
 
   //! \brief Player creation palette
   //!
   //! Contains information about available player roles and their configurations.
   //! Used for the role selection interface.
   DtPlayerCreationPalette myPlayerCreationPalette;
 
   //! \brief Role selection panel
   //!
   //! Panel used for selecting and configuring player roles.
   DtChooseRolePanel* myChoosePlayerPanel;
 
   //! \brief Fixed role mode state
   //!
   //! When true, the application uses a predetermined role rather than
   //! allowing the user to select from available roles.
   bool myFixedRoleMode;
 
   //! \brief Window dragging state
   //!
   //! Tracks whether the application window is currently being dragged.
   bool myIsDragging;
 
   //! \brief VR-Vantage controls state
   //!
   //! Controls whether VR-Vantage specific controls are enabled in the interface.
   bool myEnableVRVControls;
 
   //! \brief 3D role panel state
   //!
   //! When true, uses a 3D version of the role selection panel interface.
   //! When false, uses a 2D panel.
   bool myUse3DChooseRolePanel;
 
   //! \brief Current sensor library in use
   //!
   //! The sensor library currently in use for the application (CAMERA_FX or SENSOR_FX).
   //! Default is CAMERA_FX. Specify --enableSensorFX on the command line to switch to use
   //! SENSOR_FX instead. This determines how visual effects like night vision and
   //! thermal imaging are rendered.
   DtSensorLibrary mySensorLibrary;
 
   //! \brief Status publisher
   //!
   //! Broadcasts the state of the VR-Engage application and its player stations
   //! to other components in the distributed simulation.
   DtVreStatusPublisher* myStatusPublisher;
 
   //! \brief Status listener
   //!
   //! Monitors status messages from other VR-Engage instances and maintains a
   //! list of active stations and the entities they are engaged with.
   DtVreStatusListener* myStatusListener;
 
   //! \brief Observer modes for different states
   //! @{
 
   //! \brief Observer mode for 2D non-play states
   //!
   //! Observer mode to use while in the choosing role state when using 2D view.
   std::string myNonPlayStateObserverMode2D;
 
   //! \brief Observer mode for 3D non-play states
   //!
   //! Observer mode to use while in the choosing role state when using 3D view.
   std::string myNonPlayStateObserverMode3D;
 
   //! \brief Observer mode for play state
   //!
   //! Observer mode to use while in the play state (always 3D).
   std::string myPlayStateObserverMode;
   //! @}
 
   //! \brief Observer and sensor mode mappers
   //! @{
 
   //! \brief Observer mode mapper
   //!
   //! Utility class that maps a given key string representing a generic
   //! VR-Vantage Observer mode name (not specific to a camera FX or sensor FX library)
   //! to the specific VR-Vantage observer mode name appropriate for the sensor
   //! library currently loaded in the application. The key string is used in VR-Engage
   //! as a way to represent an observer mode in a sensor-library independent manner.
   //! Note that the use of the key string is only appropriate for use within the
   //! VR-Engage API. It must be translated into a real VR-Vantage observer mode name
   //! by this utility class any time it is used in the VR-Vantage API.
   DtVreObserverModeMapper* myVreObserverModeMapper;
 
   //! \brief Sensor mode mapper
   //!
   //! Utility class that maps a given key string representing generic VR-Vantage Sensor
   //! mode name. It is similar in purpose and function to myVreObserverModeMapper, except
   //! that instead of a generic mapping of observer mode names, it provides a generic
   //! mapping of sensor mode names, between a VR-Engage generic key string and concrete
   //! VR-Vantage sensor mode names.
   DtVreSensorModeMapper* myVreSensorModeMapper;
   //! @}
 
   //! \brief Application-level observer name
   //!
   //! Observer name for application-level observer (as opposed to any secondary
   //! additional observers that get created for particular roles). By default the
   //! observer name is "Observer 1".
   std::string myObserverName;
 
   //! \brief HUD texture reference count map
   //!
   //! Tracking map for how many HUDs are drawing each offscreen texture.
   //! Used to manage the lifecycle of shared textures.
   std::map<int, int> myActiveHudTextureLookup;
 
   //! \brief Application instance attribute store
   //!
   //! Stores a handle to the application instance in the attribute store,
   //! allowing it to be accessed from various parts of the application.
   DtAttributeHandleType<DtPlayerStationApp*> myAppStore;
 
   //! \brief Structure for deferred function execution
   //!
   //! Stores a list of functions to be executed after a delay.
   //! Functions are executed at start of app tick once tick delay or timer reaches zero.
   struct DeferredFunc
   {
      //! \brief Function to be executed
      std::function<void()> f;
 
      //! \brief Number of ticks to wait before execution
      int ticks;
 
      //! \brief Time in seconds to wait before execution
      double time;
 
      //! \brief Constructor
      //! \param _f Function to execute
      //! \param _ticks Number of ticks to wait
      //! \param _time Time in seconds to wait
      DeferredFunc(std::function<void()>& _f, int _ticks, double _time)
         : f(_f)
         , ticks(_ticks)
         , time(_time)
      {
      }
   };
 
   //! \brief List of deferred functions
   //!
   //! Contains functions that are scheduled to be executed after a delay.
   std::list<DeferredFunc> myDeferredFunList;
};
} // namespace makVre