DtVirtualRealityEventManager.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file DtVirtualRealityEventManager.h
//! \brief Defines the base class for VR controller event management
//! \ingroup vrvVirtualRealityController
//!
//! This file contains the definition of the DtVirtualRealityEventManager base class,
//! which is responsible for managing VR controller states and processing controller
//! events. It maintains a list of event processors that can respond to controller
//! events and dispatches events to these processors when they occur.
 
#pragma once
 
#include <vrvVirtualRealityController/vrvVirtualRealityController.h>
#include <vrvVirtualRealityController/DtVirtualRealityControllerEvent.h>
 
#include <vrvUtil/DtVirtualBaseClass.h>
 
namespace makVrv
{
class DtVirtualRealityDriver;
class DtVirtualRealityEventProcessorInterface;
 
//! \brief List type for storing event processor pointers
//!
//! This type is used to maintain an ordered list of event processors that will
//! receive controller events in sequence during event dispatch.
using EventProcessorList = std::list<DtVirtualRealityEventProcessorInterface*>;
 
//! \brief Base class for managing virtual reality controller events
//!
//! This abstract base class defines the interface and common functionality for
//! VR controller event management. It maintains the current state of all connected
//! controllers, processes events from the VR system, and dispatches these events
//! to registered event processors.
//!
//! Specific VR platforms (Oculus, OpenVR, etc.) implement derived classes that
//! handle the platform-specific details of retrieving controller state information.
//!
//! \note This class is created automatically by the DtVirtualRealityDriver
//!       and is not intended to be instantiated directly by users.
class DT_DLL_VRVVRCTLR DtVirtualRealityEventManager : public DtVirtualBaseClass
{
private:
   //! \brief Unused default constructor
   //!
   //! Private constructor to prevent direct instantiation. Use the instance()
   //! method to get the singleton instance instead.
   DtVirtualRealityEventManager();
 
public:
   //! \brief Map type that associates controller IDs with their state objects
   //!
   //! This map associates controller identifiers (unsigned integers) with
   //! pointers to controller state objects that contain the controller's
   //! position, orientation, and input states.
   using ControllerStateMap = std::map<unsigned int, DtVirtualRealityControllerState*>;
 
   //! \brief Gets the singleton instance of the appropriate 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 appropriate VR event manager for
   //! the current VR system (e.g., Oculus, OpenVR), 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 event manager resources, including all registered event processors
   //! and controller state objects.
   virtual ~DtVirtualRealityEventManager() override;
 
 
   //! \brief Registers an event processor at the front of the event processing queue
   //! \param processor Pointer to the event processor to register
   //!
   //! Adds the specified event processor to the front of the event processing queue.
   //! Event processors at the front of the queue receive events before those at the back.
   //! This is useful when an event processor needs to handle events before others,
   //! potentially intercepting and canceling events for other processors.
   virtual void addEventProcessorToFront(DtVirtualRealityEventProcessorInterface* processor);
 
   //! \brief Registers an event processor at the back of the event processing queue
   //! \param processor Pointer to the event processor to register
   //!
   //! Adds the specified event processor to the back of the event processing queue.
   //! Event processors at the back of the queue receive events after those at the front.
   //! This is the default and most common way to register event processors.
   virtual void addEventProcessorToBack(DtVirtualRealityEventProcessorInterface* processor);
 
   //! \brief Unregisters an event processor
   //! \param processor Pointer to the event processor to unregister
   //!
   //! Removes the specified event processor from the event processing queue.
   //! After removal, the processor will no longer receive controller events.
   //! If the processor is not in the queue, this method has no effect.
   virtual void removeEventProcessor(DtVirtualRealityEventProcessorInterface* processor);
 
   //! \brief const access the event processor list
   virtual const EventProcessorList& eventProccesorList() const;
 
   //! \brief non-const access to the event processor list
   virtual EventProcessorList& eventProccesorList();
 
   //! \brief Access the Controller State map containing the most recent state of all controllers.
   //! Map is indexed by controller id.
   const ControllerStateMap& controllerStateMap() const;
 
   //       //! \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 CTOR
   // Only called by registerInstance for default
   DtVirtualRealityEventManager(DtDe& de);
 
   //! \brief dispatch controller event to any active event handlers
   virtual void dispatchControllerEvent(DtVirtualRealityControllerEvent& event);
 
   //! \brief called every frame by the system.  Calls the processVREvents for the specific system
   virtual void tick();
 
   //! \brief collects and dispatches events from the VR system to any active event processors.
   // This is used by the DtVirtualRealityDriver and not intended to be called directly by users.
   virtual void processVrEvents() = 0;
 
protected:
   DtDe& myDe;
   DtVirtualRealityDriver* myVrDriver;
   EventProcessorList myEventProcessors;
   ControllerStateMap myControllerStates;
};
} // namespace makVrv