instrumentPanelManager.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file instrumentPanelManager.h
//! \brief Provides management for instrument panels and specialized views in simulation environments
 
#pragma once
 
#include "vrePlayerStation/export.h"
 
#include "vrePlayerStation/instrumentPanelManagerStructs.h"
 
#include <vreMessageManager/vreMessage.h>
#include <vreUtil/vector2DI.h>
 
namespace makVrv
{
class DtWindow;
class DtChannel;
class DtChannelManager;
class DtInputDriver;
class DtOsgSensorViewOverlaySectionCreator;
} // namespace makVrv
 
namespace makVre
{
class DtPlayerStationApp;
 
//! \brief Manager for instrument panels, gimbal sensors, and specialized views
//!
//! The DtInstrumentPanelManager handles creation, modification, and deletion of
//! extra channels, windows, or instrument panels used by various roles.
//! For example:
//!   - Gimbaled Sensor and PVD views for fixed wing pilots
//!   - The guard house's security panel window
//!   - The launcher's scope channel
//!   - The render-to-texture channels used by the T-38 and M1A2 3D models
//! Interaction with this class is mostly done through sending WindowOperationMessage events.
//! The manager maintains mappings between entities and their associated panels/cameras,
//! and provides functionality for controlling sensor modes and overlay elements.
class PLAYERSTATION_DLL DtInstrumentPanelManager
{
public:
   //! \brief Default constructor
   //!
   //! Initializes member variables to default values. Full initialization
   //! occurs when the init method is called.
   DtInstrumentPanelManager();
 
   //! \brief Virtual destructor
   //!
   //! Cleans up any remaining panel structures and resources.
   virtual ~DtInstrumentPanelManager();
 
   //! \brief Initializes the instrument panel manager
   //!
   //! Sets up message handlers, configures default settings for gimbal and plan views,
   //! and adds default overlay creators.
   //!
   //! \param de Pointer to the rendering engine
   //! \param app Pointer to the player station application
   //! \param resolver Pointer to the entity resolver
   //! \param windowConfig Configuration table containing window settings
   virtual void init(makVrv::DtDe* de, DtPlayerStationApp* app, DtEntityResolver* resolver, DtInitTable windowConfig);
 
   //! \brief Handles entity disengagement
   //!
   //! Cleans up resources associated with an entity when it's disengaged.
   //!
   //! \param id The identifier of the entity being disengaged
   //! \return true if successful, false otherwise
   virtual bool onDisengage(const DtEntityIdentifier& id);
 
   //! \brief Retrieves the panel structure for a given entity
   //!
   //! \param id The entity identifier
   //! \return Pointer to the panel structure or nullptr if not found
   virtual DtPanelStruct* getPanelStruct(const DtEntityIdentifier& id) const;
 
   //! \brief Retrieves a camera structure by name from a panel structure
   //!
   //! \param panelStruct The panel structure containing the camera
   //! \param name The name of the camera to retrieve
   //! \return Pointer to the camera structure or nullptr if not found
   virtual DtCameraStruct* getCameraStruct(const DtPanelStruct* panelStruct, const std::string& name) const;
 
   //! \brief Sets the sensor mode for an observer
   //!
   //! Attempts to set the sensor mode, and if the mode isn't found, tries
   //! appending the configurable mode suffix.
   //!
   //! \param observer The observer to modify
   //! \param modeName The name of the sensor mode to set
   virtual void setObserverSensorMode(makVrv::DtObserver* observer, const std::string& modeName);
 
   //! \brief Slot called on post-tick to check for pending field of view messages
   //!
   //! Processes pending stealth window creation messages when their
   //! required fields of view become available.
   virtual void slot_onPostTick();
 
   //! \brief Slot called when a channel is about to be destroyed
   //!
   //! Performs necessary cleanup for the channel and updates associated panel structures.
   //!
   //! \param mgr The channel manager
   //! \param channel The channel being destroyed
   virtual void slot_channelToBeDestroyed(makVrv::DtChannelManager* mgr, makVrv::DtChannel* channel);
 
   //! \brief Slot called when a window is about to be destroyed
   //!
   //! Performs necessary cleanup for the window and updates associated panel structures.
   //!
   //! \param window The window being destroyed
   virtual void slot_WindowToBeDestroyed(makVrv::DtWindow* window);
 
   //! \brief Handles entity removal messages
   //!
   //! Cleans up resources associated with an entity when it's removed.
   //!
   //! \param msg The entity removed message
   //! \return Message handling result
   virtual DtVreMessageResult handleEntityRemoved(DtVreMessage* msg);
 
   //! \brief Sets whether to automatically disable HDR auto exposure on certain views
   //!
   //! \param value true to automatically disable HDR auto exposure, false to leave it as is
   virtual void setAutoDisableHdrAutoExposure(bool value);
 
   //! \brief Adds or replaces an overlay section creator
   //!
   //! Each key is mapped to a creator that can generate a specific overlay section
   //! type for sensor views. This allows for configurable overlay sections.
   //!
   //! \param key The identifier for the overlay section type
   //! \param creator The creator object for generating the overlay section
   virtual void addOverlaySectionCreator(const std::string& key, makVrv::DtOsgSensorViewOverlaySectionCreator* creator);
 
protected:
   //! \brief Adds default overlay section creators
   //!
   //! Adds creators for the following keys:
   //!    - "Crosshair" - Displays 4 corners of a box
   //!    - "PlatformInfo" - Displays information about ownship entity
   //!    - "VrePlatformInfo" - Adds Date and Time displays to PlatformInfo
   //!    - "TargetInfo" - Displays ownship coordinates
   //!    - "VreTargetInfo" - Displays center of sensor's view coordinates
   //!    - "VreMgrsTargetInfo" - Displays coordinates in MGRS format
   //!    - "DisplayInfo" - Displays sensor view information
   //!    - "VreDisplayInfo" - Strips off sensor mode suffixes
   //!    - "Pitch" - Displays ladder showing sensor elevation
   //!    - "VrePitch" - Adds Pitch readout to arrow
   //!    - "Compass" - Displays sensor azimuth and platform heading
   //!    - "Reticle" - Displays cross in the middle of the screen
   //!    - "DateTime" - Displays date and time
   //!    - "Time" - Displays time only
   //!    - "Rec" - Displays static "REC" text
   virtual void addDefaultOverlayCreators();
 
   //! \brief Handles window operation messages
   //!
   //! Routes messages to the appropriate handler based on the operation type.
   //!
   //! \param msg The window operation message
   //! \return Message handling result
   virtual DtVreMessageResult handleWindowOperation(DtVreMessage* msg);
 
   //! \brief Handles messages to set gimbal overlay sections
   //!
   //! \param msg The message containing overlay section information
   //! \return Message handling result
   virtual DtVreMessageResult handleSetGimbalOverlaySections(DtVreMessage* msg);
 
   //! \brief Handles messages to restore gimbal overlay sections
   //!
   //! \param msg The message to restore overlay sections
   //! \return Message handling result
   virtual DtVreMessageResult handleRestoreGimbalOverlaySections(DtVreMessage* msg);
 
   //! \brief Handles messages to reassign panel ownership
   //!
   //! \param msg The message containing reassignment information
   //! \return Message handling result
   virtual DtVreMessageResult handleReassignPanelOwnership(DtVreMessage* msg);
 
   //! \brief Processes gimbal operations (create, destroy, modify)
   //!
   //! Handles creation, destruction, and modification of gimbal views for
   //! Multi-function Displays (MFDs). Modification cycles through sensor modes.
   //!
   //! \param msg The window operation message
   virtual void processGimbalOperation(WindowOperationMessage* msg);
 
   //! \brief Processes stealth operations
   //!
   //! \param msg The window operation message
   virtual void processStealthOperation(WindowOperationMessage* msg);
 
   //! \brief Processes plan view operations
   //!
   //! \param msg The window operation message
   virtual void processPlanViewOperation(WindowOperationMessage* msg);
 
   //! \brief Processes instrument panel operations
   //!
   //! \param msg The window operation message
   virtual void processInstrumentPanelOperation(WindowOperationMessage* msg);
 
   //! \brief Creates a gimbal view
   //!
   //! \param msg The window operation message with gimbal creation parameters
   virtual void createGimbal(WindowOperationMessage* msg);
 
   //! \brief Destroys a gimbal view
   //!
   //! \param msg The window operation message identifying the gimbal to destroy
   virtual void destroyGimbal(WindowOperationMessage* msg);
 
   //! \brief Creates a plan view
   //!
   //! \param msg The window operation message with plan view creation parameters
   virtual void createPlanView(WindowOperationMessage* msg);
 
   //! \brief Destroys a plan view
   //!
   //! \param msg The window operation message identifying the plan view to destroy
   virtual void destroyPlanView(WindowOperationMessage* msg);
 
   //! \brief Creates an instrument panel
   //!
   //! \param msg The window operation message with instrument panel creation parameters
   virtual void createInstrumentPanel(WindowOperationMessage* msg);
 
   //! \brief Destroys an instrument panel
   //!
   //! \param msg The window operation message identifying the instrument panel to destroy
   virtual void destroyInstrumentPanel(WindowOperationMessage* msg);
 
   //! \brief Creates a render-to-texture instrument panel
   //!
   //! \param msg The window operation message with RTT panel creation parameters
   virtual void createInstrumentPanelRtt(WindowOperationMessage* msg);
 
   //! \brief Destroys a render-to-texture instrument panel
   //!
   //! \param msg The window operation message identifying the RTT panel to destroy
   virtual void destroyInstrumentPanelRtt(WindowOperationMessage* msg);
 
   //! \brief Creates a stealth window
   //!
   //! \param msg The window operation message with stealth window creation parameters
   virtual void createStealth(WindowOperationMessage* msg);
 
   //! \brief Destroys a stealth window
   //!
   //! \param msg The window operation message identifying the stealth window to destroy
   //! \param[out] destroyed Set to true if the window was successfully destroyed; false otherwise
   virtual void destroyStealth(WindowOperationMessage* msg, bool& destroyed);
 
   //! \brief Destroys all stealth windows
   //!
   //! \param msg The window operation message
   virtual void destroyAllStealth(WindowOperationMessage* msg);
 
   //! \brief Handles minimap-related messages
   //!
   //! \param msg The minimap message
   //! \return Message handling result
   virtual DtVreMessageResult handleMinimapMessage(DtVreMessage* msg);
 
   //! \brief Handles messages to set gimbal sensor mode
   //!
   //! \param msg The message containing sensor mode information
   //! \return Message handling result
   virtual DtVreMessageResult handleSetGimbalSensorMode(DtVreMessage* msg);
 
   //! \brief Sets the current selection
   //!
   //! \param id The ID of the entity to select
   virtual void setCurrentSelection(makVrv::DtUniqueID id);
 
   //! \brief Clears the current selection
   virtual void clearCurrentSelection();
 
   //! \brief Finds or creates a panel structure for a given message
   //!
   //! \param msg The window operation message
   //! \return Pointer to the panel structure
   virtual DtPanelStruct* findOrCreatePanelStruct(const WindowOperationMessage* msg);
 
   //! \brief Finds or creates a camera structure
   //!
   //! \param panelStruct The panel structure to add the camera to
   //! \param cameraType The type of camera to create
   //! \param name The name of the camera
   //! \return Pointer to the camera structure
   virtual DtCameraStruct* findOrCreateCameraStruct(
      DtPanelStruct* panelStruct, DtCameraType cameraType, std::string name);
 
   //! \brief Slot called when an observer is created
   //!
   //! Sets the observer name and sensor mode in the camera.
   //!
   //! \param inputDriver The input driver
   //! \param observer The observer that was created
   //! \param cameraStruct The camera structure to update
   virtual void slot_observerCreated(
      makVrv::DtInputDriver* inputDriver, makVrv::DtObserver* observer, DtCameraStruct* cameraStruct);
 
   //! \brief Pointer to the rendering engine
   makVrv::DtDe* myDe;
 
   //! \brief Pointer to the player station application
   DtPlayerStationApp* myApp;
 
   //! \brief Pointer to the entity resolver
   DtEntityResolver* myEntityResolver;
 
   //! \brief Current sensor mode for gimbal views
   std::string myGimbalViewSensorMode;
 
   //! \brief Default position for gimbal views
   DtVector2DI myGimbalPosition;
 
   //! \brief Default size for gimbal views
   DtVector2DI myGimbalSize;
 
   //! \brief Resolution for plan views
   int myPlanViewResolution;
 
   //! \brief Default position for plan views
   DtVector2DI myPlanViewPosition;
 
   //! \brief Default size for plan views
   DtVector2DI myPlanViewSize;
 
   //! \brief Map of entity identifiers to panel structures
   using DtEntityPanelMap = std::map<DtEntityIdentifier, DtPanelStruct*>;
 
   //! \brief Map storing all entity-panel associations
   DtEntityPanelMap myEntityPanelMap;
 
   //! \brief Suffix to append when searching for observer modes
   //!
   //! If a requested observer mode can't be found, append
   //! either " (CameraFX)" or " (SensorFX)" and search again.
   std::string myObserverModeSuffix;
 
   //! \brief Storage for pending field of view messages
   //!
   //! Stores copies of messages when the required field
   //! of view does not exist yet.
   std::vector<WindowOperationMessage*> myPendingFieldOfView;
 
   //! \brief Map of overlay section keys to their creator objects
   //!
   //! Maps string keys to DtOsgSensorViewOverlaySectionCreators, allowing
   //! users to configure which overlay sections to use depending on
   //! their role or entity.
   using DtStringOverlayCreatorMap = std::map<std::string, makVrv::DtOsgSensorViewOverlaySectionCreator*>;
 
   //! \brief Map storing all overlay section creators
   DtStringOverlayCreatorMap myOverlayCreatorMap;
 
   //! \brief Flag to control HDR auto exposure behavior
   //!
   //! When true, HDR auto exposure will be automatically disabled for
   //! certain types of views.
   bool myAutoDisableHdrAutoExposure;
};
} // namespace makVre