glstudioHudMapperLogic.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file glstudioHudMapperLogic.h
//! \brief Defines the DtGlStudioHudMapperLogic component for managing GLStudio-based cockpit displays.
//!
//! This component provides functionality to configure and manage cockpit displays and instrument panels
//! created with GLStudio. It handles mapping entity types to model definitions and manages configurations
//! for multiple instrument panels.
//!
//! \ingroup vreCommonComponents
 
#pragma once
 
#include "vreCommonComponents/export.h"
#include "vrePlayerStation/playerComponent.h"
 
#include <vreMessageManager/vreMessage.h>
 
#include <vector>
#include <string>
 
namespace makVre
{
namespace GlStudioHudMapperLogicConfig
{
//! \ingroup RoleConfigParams
//! \defgroup GlStudioHudMapperLogicRoleParams GLStudio HUD Mapper Logic Role Parameters
//! \roleInherits{PlayerComponentRoleParams}
//! Configuration Options for GLStudio HUD mapper logic role.
//! @{
 
//! \vreRoleParam{instrumentPanels,table,{},glStudioHudMapperLogic,Table of instrument panel configurations for creating multiple cockpit displays and panels.}
constexpr const char* instrumentPanels = "instrumentPanels";
 
//! \vreRoleParam{modelDefinitions,table,{},glStudioHudMapperLogic,Table or string of GLStudio model definition files for mapping entity types to cockpit models.}
constexpr const char* modelDefinitions = "modelDefinitions";
 
//! \vreRoleParam{properties,table,{},glStudioHudMapperLogic,Properties configuration block for main cockpit display panel settings.}
constexpr const char* properties = "properties";
 
//! \vreRoleParam{realCockpit,bool,false,glStudioHudMapperLogic,Flag indicating whether this is a real cockpit display configuration.}
constexpr const char* realCockpit = "realCockpit";
 
//! @}
} // namespace GlStudioHudMapperLogicConfig
 
//! \brief Type identifier for DtGlStudioHudMapperLogic component
constexpr const char* DtGlStudioHudMapperLogicType = "DtGlStudioHudMapperLogic";
 
//! \brief Component for managing GLStudio-based cockpit displays and instrument panels
//!
//! The DtGlStudioHudMapperLogic handles configuration and management of cockpit displays
//! and instrument panels created with GLStudio. It supports:
//! - Mapping entity types to model definitions for cockpit displays
//! - Creating and configuring multiple instrument panels
//! - Handling configuration requests from GLStudio components
//! - Managing panel properties and configurations
//!
//! This component works in conjunction with GLStudio to provide a complete cockpit visualization
//! system for vehicle roles.
class VRECOMMONCOMPONENTS_DLL DtGlStudioHudMapperLogic : public DtPlayerComponent
{
public:
   //! \brief Constructor for DtGlStudioHudMapperLogic
   //!
   //! Initializes the component with the name "DtGlStudioHudMapperLogic" and empty model definitions
   //! and panel configurations.
   DtGlStudioHudMapperLogic();
 
   //! \brief Virtual destructor for DtGlStudioHudMapperLogic
   virtual ~DtGlStudioHudMapperLogic() override;
 
   //! \brief Initializes the component with configuration from Lua
   //!
   //! Sets up the model definitions for cockpit displays, processes instrument panel configurations,
   //! and adds a handler for GLStudio configuration requests. The method also sets the "realCockpit"
   //! state attribute based on configuration.
   //!
   //! Configuration parameters include:
   //! - modelDefinitions: String or table of strings defining cockpit model definitions
   //! - properties: Table of properties for the main cockpit display
   //! - realCockpit: Boolean flag indicating if this is a real cockpit (default: false)
   //! - instrumentPanels: Table of instrument panel configurations
   //!
   //! \param player Pointer to the player station this component belongs to
   //! \param config Configuration table containing initialization parameters
   //! \return True if initialization succeeds, false otherwise
   virtual bool initialize(makVre::DtPlayerStation* player, makVre::DtInitTable& config) override;
 
   //! \brief Updates the component state (empty implementation)
   //!
   //! This method is called each frame but currently has no implementation.
   //!
   //! \param dt Delta time in seconds since the last tick
   virtual void tick(double dt) override;
 
   //! \brief Shuts down the component
   //!
   //! Closes all instrument panels associated with this entity by sending a WindowOperationMessage
   //! with the OperationType_Destroy operation. Also removes the GLStudio configuration request handler.
   virtual void shutdown() override;
 
   //! \brief Returns the component type identifier
   //! \return The component type string
   virtual const char* type() const override;
 
protected:
   //! \brief Creates instrument panels used by the current display layout
   //!
   //! Processes the "instrumentPanels" section from the configuration and creates instrument
   //! panels with the specified properties. For each panel, sends a WindowOperationMessage
   //! to create a new instrument panel window with the specified parameters.
   //!
   //! Panel configuration parameters include:
   //! - modelDefinition: GLStudio model definition to use
   //! - panelPositionX/Y: Screen coordinates for panel position
   //! - panelSizeX/Y: Panel dimensions
   //! - screen: Screen index to display on
   //! - fullscreen: Whether the panel should be fullscreen
   //! - cockpitOnly: Whether to display only when in cockpit view
   //! - panelId: Unique identifier for the panel (for configuration)
   //! - additionalChannelKeywords: Additional channel keywords
   //!
   //! \param config Configuration table containing instrument panel settings
   virtual void createInstrumentPanels(makVre::DtInitTable& config);
 
   //! \brief Handles configuration requests from GLStudio components
   //!
   //! Processes GlsConfigRequestMessages by looking up the requested panel ID in the
   //! myPanelConfigurations map. If found, sends a GlsConfigResponseMessage with the
   //! panel's properties.
   //!
   //! Properties are defined in the "properties" section of a panel's configuration
   //! as key-value pairs.
   //!
   //! \param msg The message to process (expected to be a GlsConfigRequestMessage)
   //! \return HANDLED if the message was processed successfully
   virtual makVre::DtVreMessageResult handleGlsConfigRequest(makVre::DtVreMessage* msg);
 
protected:
   //! \brief List of model definitions for cockpit displays
   //!
   //! These model definitions are registered with the DtSharedCockpitSettings
   //! to map entity types to cockpit models.
   std::vector<std::string> myModelDefinitions;
 
   //! \brief Map of panel IDs to their configuration data
   //!
   //! This map stores initialization data for instrument panels, allowing the component
   //! to respond to panel configuration requests. The key is the panel ID, and the value
   //! is the configuration table containing the panel's properties.
   //!
   //! An empty string key represents the main cockpit display's configuration.
   std::map<std::string, DtInitTable> myPanelConfigurations;
};
} // namespace makVre