DtOpenVREventManager.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file DtOpenVREventManager.h
//! \brief OpenVR-specific implementation of VR controller event management
//! \ingroup vrvVirtualRealityController
//!
//! This file contains the OpenVR-specific implementation of the virtual reality
//! event manager. It handles processing of SteamVR/OpenVR controller inputs and
//! translating them into a common VR controller event format used throughout
//! the application.
 
#pragma once
 
#include <vrvVirtualRealityController/vrvVirtualRealityController.h>
#include <vrvVirtualRealityController/DtVirtualRealityEventManager.h>
 
namespace vr
{
class IVRSystem;
struct VREvent_t;
} // namespace vr
 
namespace makVrv
{
//! \brief OpenVR-specific implementation of the virtual reality event manager
//!
//! This class is responsible for processing SteamVR/OpenVR controller events and
//! translating them into the common VR controller event format. It communicates
//! with the OpenVR API to retrieve controller state information and dispatches
//! controller events to registered event processors.
//!
//! \note This class is created automatically by the DtVirtualRealityDriver
//!       and is not intended to be instantiated directly by users.
class DT_DLL_VRVVRCTLR DtOpenVREventManager : public DtVirtualRealityEventManager
{
private:
   //! \brief Unused default constructor
   //!
   //! Private constructor to prevent direct instantiation. Use the instance()
   //! method to get the singleton instance instead.
   DtOpenVREventManager();
 
public:
   //! \brief Gets the singleton instance of the OpenVR event manager
   //! \param de Reference to the display engine
   //! \return Reference to the singleton instance
   //! \throws DtCorruptedState if it is unable to get the instance
   //!
   //! Returns the singleton instance of the OpenVR event manager, creating it
   //! if it doesn't already exist. This method is called by the VR driver
   //! during initialization.
   static DtVirtualRealityEventManager& instance(DtDe& de);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up OpenVR event manager resources and releases connections
   //! to the OpenVR API.
   virtual ~DtOpenVREventManager() override;
 
   //       //! \brief get/set the deadzone for the given axis of the given controller.
   //       virtual DtVector2f deadZone(DtVirtualRealityControllerState::Controller,
   //       DtVirtualRealityControllerState::Axis) const; virtual void
   //       setDeadZone(DtVirtualRealityControllerState::Controller, DtVirtualRealityControllerState::Axis, const
   //       DtVector2f&);
 
protected:
   //! \brief Constructor
   //! \param de Reference to the display engine
   //!
   //! Initializes the OpenVR event manager with a reference to the display engine.
   //! This constructor is only called by the registerInstance method and
   //! should not be called directly.
   DtOpenVREventManager(DtDe& de);
 
 
   //! \brief Collects and dispatches events from the OpenVR system
   //!
   //! Polls the OpenVR API for controller state updates, processes button and
   //! analog input events, and dispatches them to registered event processors.
   //!
   //! \note This method is called by the DtVirtualRealityDriver during the
   //!       update cycle and is not intended to be called directly by users.
   virtual void processVrEvents() override;
 
   //! \brief Updates controller state for a specific controller
   //! \param deviceId The controller identifier to update
   //! \param state Reference to the controller state to update
   //!
   //! Updates the provided controller state object with the latest data from
   //! the OpenVR controller with the specified device ID. This includes position,
   //! orientation, button states, and analog input values.
   virtual void updateControllerState(
      DtVirtualRealityControllerState::ControllerId deviceId, DtVirtualRealityControllerState& state);
 
   //! \brief Determines the device type for a given controller ID
   //! \param deviceId The controller identifier to query
   //! \return Bitfield representing the device type
   //!
   //! Maps an OpenVR-specific device identifier to the common controller device
   //! type enumeration used throughout the application.
   virtual DtVirtualRealityControllerState::Bitfield findDeviceType(
      DtVirtualRealityControllerState::ControllerId deviceId) const;
 
protected:
   //! \brief Pointer to the OpenVR system interface
   //!
   //! This pointer is used to communicate with the OpenVR API for retrieving
   //! controller state information and processing events.
   vr::IVRSystem* myVrSystem;
};
} // namespace makVrv