vrvKeyboardMouseDevice.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
 
//! \file
//! \brief Input device that processes keyboard and mouse events
 
#pragma once
 
#include "vreInput/export.h"
#include "vreInput/inputDevice.h"
#include "vreInput/inputData.h"
 
#include "vreMessageManager/vreMessage.h"
 
#include <vrvCore/DtEventProcessorInterface.h>
#include <vrvCore/DtMouseEvent.h>
#include <memory>
 
 
namespace makVrv
{
//! Forward declarations
class DtChannel;
} // namespace makVrv
 
namespace makVre
{
//! Forward declarations
class DtMouseControl;
class DtInitTable;
class DtPlayerStation;
 
//! \brief Input device that processes keyboard and mouse events from VR-Vantage
//!
//! This class bridges the gap between the core event system and the input system
//! by implementing both DtInputDevice and DtEventProcessorInterface. It receives
//! keyboard and mouse events from the core system and translates them into
//! DtInputData structures that can be processed by the input manager.
class VREINPUT_DLL DtVrvKeyboardMouseDevice : public DtInputDevice, makVrv::DtEventProcessorInterface
{
public:
   //! \brief Structure for keyboard input configuration
   //!
   //! Used to configure mappings between keyboard keys and input actions
   struct KeyInput
   {
      std::string key;      //!< Key identifier (key name or code)
      std::string keyState; //!< State of the key (pressed, released, etc.)
      std::string modifier; //!< Modifier keys that must be active (shift, ctrl, etc.)
      double value;         //!< Value to assign to the input when triggered
   };
 
   //! \brief Structure for keyboard action definition
   //!
   //! Defines an action that can be triggered by a keyboard input
   struct KeyboardAction
   {
      std::string name; //!< Name of the action to trigger
      double value;     //!< Value to assign to the action when triggered
   };
 
   //! \brief Default constructor
   //!
   //! Initializes the event processor and sets up default values
   DtVrvKeyboardMouseDevice();
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources owned by the event processor
   virtual ~DtVrvKeyboardMouseDevice() override;
 
   //! \brief Initializes the event processor
   //!
   //! Sets up the event processor with the input manager and initializes
   //! mouse control and event handling structures. Registers message handlers.
   //!
   //! \param mgr Reference to the input manager that owns this device
   //! \return True if initialization succeeded, false otherwise
   virtual bool init(DtVreInputManager& mgr) override;
 
   //! \brief Shuts down the event processor
   //!
   //! Unregisters message handlers and cleans up resources allocated during initialization
   virtual void shutdown() override;
 
   //! \brief Reports the current state of input device controls
   //!
   //! Empty implementation as there's no persistent state to report for keyboard/mouse
   virtual void reportCurrentState() override {};
 
   //! \brief Updates the event processor for the current frame
   //!
   //! Handles time-based updates including mouse movement processing
   //!
   //! \param dt Delta time in seconds since the last frame
   virtual void tick(double dt) override;
 
   //! \brief Processes keyboard events from the core system
   //!
   //! Translates core keyboard events into input data structures and forwards
   //! them to the input manager for processing.
   //!
   //! \param ev The keyboard event to process
   //! \param channel The channel from which the event originated
   //! \return True if the event was handled, false otherwise
   virtual bool processKeyboardEvent(const makVrv::DtKeyEvent& ev, makVrv::DtChannel& channel) override;
 
   //! \brief Processes mouse events from the core system
   //!
   //! Translates core mouse events (clicks, scrolls) into input data structures
   //! and forwards them to the input manager for processing.
   //!
   //! \param ev The mouse event to process
   //! \param channel The channel from which the event originated
   //! \return True if the event was handled, false otherwise
   virtual bool processMouseEvent(const makVrv::DtMouseEvent& ev, makVrv::DtChannel& channel) override;
 
   //! \brief Processes mouse movement events
   //!
   //! Handles mouse movement and converts it into input data for the input manager.
   //! This is called separately from processMouseEvent for continuous mouse movement.
   //!
   //! \param x The x-coordinate of the mouse cursor
   //! \param y The y-coordinate of the mouse cursor
   virtual void processMouseMove(float x, float y);
 
   //! \brief Gets the class name of this event processor
   //!
   //! Implements the DtEventProcessorInterface requirement to provide a class name.
   //!
   //! \return Reference to a string containing the class name
   virtual const std::string& className() override;
 
protected:
   //! \brief Handles messages to enable or disable VRV input processing
   //!
   //! Message handler that toggles whether VRV input events are processed
   //!
   //! \param msg Pointer to the message to handle
   //! \return Result indicating whether the message was handled
   virtual DtVreMessageResult handleSetVRVInputEnabled(DtVreMessage* msg);
 
   //! \brief Sets up mouse click input data
   //!
   //! Helper method to populate mouse input data structure for button clicks
   //!
   //! \param button The mouse button that was clicked
   //! \param doubleClick Whether this is a double-click event
   //! \param raised Whether the button was raised (released) or pressed
   virtual void setMouseClickData(DtMouseButton button, bool doubleClick, bool raised);
 
   //! \brief Class name for identification in the event system
   std::string myClassName;
 
   //! \brief Pointer to the input manager that owns this device
   DtVreInputManager* myManager;
 
   //! \brief Flag indicating whether VRV input processing is enabled
   bool myVRVInputEnabled;
 
   //! \brief Reusable structure for mouse input data
   DtInputData myMouseInputData;
 
   //! \brief Reusable structure for keyboard input data
   DtInputData myKeyboardInputData;
 
   //! \brief Mouse control object for handling mouse behavior
   std::unique_ptr<DtMouseControl> myMouseControl;
 
   //! \brief Timestamp of the last mouse move update
   double myLastMouseMoveUpdate;
 
   //! \brief Tracking state for double-click detection (one entry per button)
   std::vector<bool> myMouseDoubleClickState{false, false, false};
};
 
} // namespace makVre