inputEvaluator.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
 
//! \file
//! \brief Defines evaluators that convert input data to actions
 
#pragma once
 
#include "vreInput/export.h"
 
#include <string>
#include <vector>
#include <memory>
 
namespace makVre
{
//! Forward declarations
class DtValueTransform;
class DtVreInputManager;
class DtInitTable;
struct DtInputData;
struct DtAction;
 
//! \brief Evaluates input data and converts it to actions
//!
//! This class evaluates input data from devices and determines if it should
//! trigger an action. It applies transformations to the input values and
//! handles features like input repetition and smoothing.
class VREINPUT_DLL DtInputEvaluator
{
public:
   //! \brief Constructor that initializes the evaluator
   //!
   //! Creates a new input evaluator with the given configuration.
   //!
   //! \param mapper Reference to the input manager
   //! \param group The input group name for organizing related evaluators
   //! \param config Pointer to the configuration data for this evaluator
   DtInputEvaluator(DtVreInputManager& mapper, const std::string& group, DtInitTable* config);
 
   //! \brief Virtual destructor
   virtual ~DtInputEvaluator();
 
   //! \brief Copy constructor (deleted)
   //!
   //! Input evaluators cannot be copied due to unique ownership of transforms
   DtInputEvaluator(const DtInputEvaluator& mapping) = delete;
 
   //! \brief Assignment operator (deleted)
   //!
   //! Input evaluators cannot be assigned due to unique ownership of transforms
   DtInputEvaluator& operator=(const DtInputEvaluator&) = delete;
 
   //! \brief Evaluates input data to determine if an action should be triggered
   //!
   //! Processes the input data by applying transformations and determining
   //! if it should trigger the associated action. If an action is triggered,
   //! it creates an Action event and dispatches it to the event manager.
   //!
   //! \param data The input data structure containing the event information
   //! \return True if an action was triggered, false otherwise
   virtual bool evaluate(const DtInputData& data);
 
   //! \brief Initializes or reinitializes the evaluator
   //!
   //! Resets the state of the evaluator to its initial values. May be called
   //! multiple times to reset the evaluator's state during runtime.
   virtual void initialize();
 
   //! \brief Updates time-based functionality for input evaluation
   //!
   //! Handles time-based evaluations such as input repetition based on
   //! the configured repeat rate. Should be called once per frame.
   //!
   //! \param dt Delta time in seconds since the last frame
   virtual void tick(double dt);
 
   //! \brief Checks if the action associated with this evaluator can be triggered
   //!
   //! Determines whether an action handler is registered for this evaluator's action.
   //! If no handler is registered, the action cannot be evaluated or triggered.
   //!
   //! \return True if the action can be evaluated (has a registered handler), false otherwise
   virtual bool canEvaluate() const;
 
   //! \brief Gets the action name associated with this evaluator
   //!
   //! Returns the name of the action that this evaluator triggers when
   //! its input conditions are met.
   //!
   //! \return String containing the action name
   virtual const std::string& getActionName() const { return myAction; }
 
   //! \brief Executes the associated action with the given value
   //!
   //! Passes the transformed input value to the registered action handler,
   //! triggering the action in the system.
   //!
   //! \param value The final transformed value to pass to the action handler
   virtual void executeAction(float value);
 
protected:
   //! \brief Reference to the input manager that owns this evaluator
   DtVreInputManager& myManager;
 
   //! \brief Group name this evaluator's action is part of.
   std::string myGroup;
 
   //! \brief Name of the action associated with this evaluator
   std::string myAction;
 
   //! \brief List of value transformations to apply to input values
   std::vector<std::unique_ptr<DtValueTransform>> myTransforms;
 
   //! \brief Current input value after processing
   float myInputValue;
 
   //! \brief Flag indicating if input should be repeated when held
   bool myRepeatInput;
 
   //! \brief Rate at which input should be repeated (in Hz)
   float myRepeatRate;
 
   //! \brief Simulation time when the next repeated input should occur
   double myNextRepeatTime;
 
   //! \brief Flag indicating if input smoothing is enabled
   bool mySmoothing;
 
   //! \brief Buffer for smoothing input values
   float myInputBuffer;
};
 
} // namespace makVre