DtVirtualRealityControllerEvent.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file DtVirtualRealityControllerEvent.h
//! \brief Defines a class that encapsulates VR controller events
//! \ingroup vrvVirtualRealityController
//!
//! This file contains the definition of the DtVirtualRealityControllerEvent class,
//! which encapsulates the state of all VR controllers at a specific point in time
//! when an event occurred. This provides a snapshot of controller positions, orientations,
//! and input states that can be processed by event handlers.
 
#pragma once
 
#include <vrvVirtualRealityController/vrvVirtualRealityController.h>
#include <vrvVirtualRealityController/DtVirtualRealityControllerState.h>
 
namespace makVrv
{
//! \brief Encapsulates a virtual reality controller event
//!
//! This class represents a snapshot of all controller states at the moment
//! an event occurred in the VR system. It provides access to the position,
//! orientation, button states, and analog input values for all connected
//! controllers. Event handlers can use this information to determine what
//! actions to take in response to user input.
class DT_DLL_VRVVRCTLR DtVirtualRealityControllerEvent
{
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 Constructor
   //! \param controllerStates Map of controller states at the time of the event
   //!
   //! Initializes a new controller event with a map of controller states.
   //! The constructor makes deep copies of all controller state objects
   //! to ensure the event represents an immutable snapshot in time.
   DtVirtualRealityControllerEvent(const ControllerStateMap& controllerStates);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up all controller state objects owned by this event.
   //! Since this class takes ownership of the controller state objects
   //! it contains, it's responsible for deleting them when destroyed.
   virtual ~DtVirtualRealityControllerEvent();
 
   //! \brief Copy constructor
   //! \param orig The event to copy
   //!
   //! Creates a new controller event that is a deep copy of the original.
   //! This ensures that each event instance has its own independent set
   //! of controller state objects.
   DtVirtualRealityControllerEvent(const DtVirtualRealityControllerEvent& orig);
 
   //! \brief Assignment operator
   //! \param rhs The event to copy
   //! \return Reference to this object after assignment
   //!
   //! Assigns the contents of another controller event to this one,
   //! performing a deep copy of all controller state objects.
   DtVirtualRealityControllerEvent& operator=(const DtVirtualRealityControllerEvent& rhs);
 
   //! \brief Gets the controller states at the time this event occurred
   //! \return Constant reference to the map of controller states
   //!
   //! Returns a read-only reference to the map of controller states that were
   //! captured when this event occurred. The map associates controller IDs with
   //! their corresponding state objects.
   virtual const ControllerStateMap& controllerStates() const;
 
protected:
   //! \brief Map of controller states at the time of the event
   //!
   //! This map contains the state of all controllers at the time the event
   //! occurred. Each entry associates a controller ID with a pointer to a
   //! controller state object that this class owns and will delete.
   ControllerStateMap myControllerStates;
};
} // namespace makVrv