inputLogic.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file inputLogic.h
//! \brief Defines the DtInputLogic class for handling input in VR-Engage
//!
//! This file contains the DtInputLogic class which provides a layer of abstraction
//! for handling user input in VR-Engage. It manages the loading and unloading of
//! input configuration files, and the registration and removal of action handlers
//! for responding to input events.
 
#pragma once
 
#include "vrePlayerStation/export.h"
 
#include "vreInput/vreInputManager.h"
 
#include <string>
#include <unordered_map>
 
namespace makVre
{
//! \brief Class for managing input configuration and handling in VR-Engage
//!
//! DtInputLogic provides a centralized mechanism for managing input configurations
//! and handling input events in VR-Engage. It allows loading input mapping configurations,
//! registering callback functions for specific actions, and managing raw input handlers.
//!
//! Input is organized into groups, which can be loaded, enabled, and disabled as units.
//! This allows different parts of the application to manage their own input requirements
//! without interfering with each other.
class PLAYERSTATION_DLL DtInputLogic
{
public:
   //! \brief Constructor
   //!
   //! Creates a new input logic handler with no configurations loaded.
   DtInputLogic();
 
   //! \brief Virtual destructor
   //!
   //! Ensures proper cleanup of derived input logic handlers.
   virtual ~DtInputLogic();
 
   //! \brief Initializes the input logic system
   //!
   //! Sets up the input manager and prepares the system for input handling.
   //! This should be called before any other input logic methods.
   virtual void initialize();
 
   //! \brief Shuts down the input logic system
   //!
   //! Removes all loaded input mappings and action callbacks from the input manager.
   //! This should be called when the system is no longer needed to properly
   //! clean up resources and prevent callback execution after destruction.
   virtual void shutdown();
 
   //! \brief Loads input mappings from a configuration file
   //! \param config Name of the configuration file to load
   //! \param group Name of the group to associate with these mappings
   //! \param alwaysOnTop Whether these mappings should always be at the top of the priority stack
   //! \param alwaysEnabled Whether these mappings should always be enabled
   //! \return True if the configuration was loaded successfully, false otherwise
   //!
   //! Loads mappings from the specified configuration file into the input manager,
   //! associating them with the given group name. The alwaysOnTop and alwaysEnabled
   //! parameters control the priority and activation state of the mappings.
   virtual bool loadInputConfig(
      const std::string& config, const std::string& group, bool alwaysOnTop = false, bool alwaysEnabled = false);
 
   //! \brief Removes previously loaded input mappings
   //! \param category Name of the mapping category to unload
   //! \param group Name of the group to unload
   //!
   //! Removes input mappings previously loaded from the specified category and group.
   //! This will prevent the mappings from triggering actions but does not remove
   //! the action handlers themselves.
   virtual void unloadInputConfig(const std::string& category, const std::string& group);
 
   //! \brief Registers a callback function to handle an input-triggered action
   //! \param group Name of the group to associate this handler with
   //! \param action Name of the action to handle
   //! \param handler Delegate function to call when the action is triggered
   //!
   //! Registers a callback function that will be called when the specified action
   //! is triggered by user input. The handler is associated with the given group,
   //! allowing for management of related action handlers as a unit.
   virtual void addActionHandler(const std::string& group, const std::string& action, const DtActionDelegate& handler);
 
   //! \brief Removes all action handlers in a group
   //! \param group Name of the group to remove
   //!
   //! Removes all action handlers associated with the specified group.
   //! This is useful for cleaning up handlers when a component is being disabled
   //! or destroyed.
   virtual void removeActionGroup(const std::string& group);
 
   //! \brief Sets a handler for raw input events
   //! \param inputDelegate Delegate function to call for raw input events
   //!
   //! Sets a function to receive all raw input events before they are processed
   //! by the normal action system. This allows for custom input handling beyond
   //! the configured actions.
   virtual void setRawInputHandler(const DtInputDelegate& inputDelegate);
 
   //! \brief Removes the current raw input handler
   //!
   //! Removes any previously set raw input handler, stopping the delivery
   //! of raw input events to the handler function.
   virtual void removeRawInputHandler();
 
   //! \brief Unregisters a specific action callback
   //! \param group Name of the group containing the action
   //! \param action Name of the action to remove the handler for
   //!
   //! Removes the callback function for the specified action within the given group.
   //! After removal, the action will no longer trigger the callback.
   virtual void removeActionHandler(const std::string& group, const std::string& action);
 
protected:
   //! \brief Pointer to the VR-Engage input manager
   DtVreInputManager* myInputManager;
 
   //! \brief List of loaded input configurations (category, group pairs)
   std::vector<std::pair<std::string, std::string>> myInputConfigurations;
 
   //! \brief Map of action groups to lists of action names
   std::unordered_map<std::string, std::vector<std::string>> myActionGroups;
 
   //! \brief Flag indicating whether raw input handling is active
   bool myHandlingRawInput;
};
 
} // namespace makVre