DtVirtualRealityEventProcessorInterface.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file DtVirtualRealityEventProcessorInterface.h
//! \brief Defines an interface for processing VR controller events
//! \ingroup vrvVirtualRealityController
//!
//! This file contains the definition of the DtVirtualRealityEventProcessorInterface class,
//! which defines the interface that must be implemented by any class that wants to
//! receive and process VR controller events. Event processors are registered with the
//! DtVirtualRealityEventManager, which dispatches controller events to them.
 
#pragma once
 
#include <vrvVirtualRealityController/vrvVirtualRealityController.h>
#include <vrvVirtualRealityController/DtVirtualRealityControllerEvent.h>
 
namespace makVrv
{
//! \brief Interface for processing virtual reality controller events
//!
//! This abstract base class defines the interface that must be implemented by any
//! class that wants to receive and process VR controller events. Event processors
//! are registered with the DtVirtualRealityEventManager, which dispatches controller
//! events to them in the order they are registered. Event processors can be enabled
//! or disabled to control whether they receive events.
class DT_DLL_VRVVRCTLR DtVirtualRealityEventProcessorInterface
{
public:
   //! \brief Default constructor
   //!
   //! Initializes a new event processor with default settings.
   //! By default, the processor is enabled (will receive events when registered).
   DtVirtualRealityEventProcessorInterface();
 
   //! \brief Virtual destructor
   //!
   //! Ensures proper cleanup of derived classes.
   virtual ~DtVirtualRealityEventProcessorInterface();
 
   //! \brief Processes a VR controller event
   //! \param ev The controller event to process
   //! \return True if the event was handled and should not be processed further,
   //!         false to allow the event to be passed to the next processor
   //!
   //! This pure virtual method must be implemented by derived classes to define
   //! how they respond to controller events. If the method returns true, the event
   //! is considered handled and will not be passed to any further event processors.
   //! If it returns false, the event will be passed to the next processor in the queue.
   virtual bool processControllerEvent(const DtVirtualRealityControllerEvent& ev) = 0;
 
   //! \brief Enables or disables the event processor
   //! \param enable True to enable the processor, false to disable it
   //!
   //! When enabled (the default), the processor will receive controller events.
   //! When disabled, the processor will remain registered but will not receive
   //! any events until it is enabled again.
   virtual void setEnabled(bool enable);
 
   //! \brief Checks if the event processor is enabled
   //! \return True if the processor is enabled, false if disabled
   //!
   //! Returns whether the processor is currently enabled to receive events.
   virtual bool enabled() const;
 
protected:
   //! \brief Flag indicating whether this processor is enabled
   //!
   //! When true, this processor will receive controller events. When false,
   //! it will remain registered but will not receive any events.
   bool myEnabled;
};
} // namespace makVrv