humanVirtualRealityLogic.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
******************************************************************************/
 
//! \file humanVirtualRealityLogic.h
//! \brief Defines DtHumanVirtualRealityLogic for managing human-specific VR interaction
//! \ingroup vreHumanFrontend
 
#pragma once
 
#include "vreHumanFrontend/export.h"
 
#include "vrePlayerStation/playerComponent.h"
#include "vreUtil/attribute.h"
 
#include "vreUtil/virtualDpad.h"
 
#include <vrvVirtualRealityController/DtVirtualRealityEventManager.h>
#include <vrvVirtualRealityController/DtVirtualRealityControllerState.h>
 
#include <vreMessageManager/vreMessage.h>
 
namespace makVre
{
 
namespace HumanVirtualRealityLogicConfig
{
//! \ingroup RoleConfigParams
//! \defgroup HumanVirtualRealityLogicRoleParams Human Virtual Reality Logic Role Parameters
//! \roleInherits{PlayerComponentRoleParams}
//! Configuration Options for human virtual reality logic component.
//! @{
 
//! \vreRoleParam{rightHanded,bool,true,humanVirtualRealityLogic,Whether the user is right-handed for VR controller handedness mapping.}
constexpr const char* rightHanded = "rightHanded";
 
//! @}
} // namespace HumanVirtualRealityLogicConfig
 
} // namespace makVre
 
namespace makVrv
{
//! \brief Forward declaration of the display element class
class DtDe;
 
//! \brief Forward declaration of the observer class
class DtObserver;
 
//! \brief Forward declaration of the virtual reality driver class
class DtVirtualRealityDriver;
 
//! \brief Forward declaration of the submit overlay callback class
class DtSubmitOverlayCallback;
} // namespace makVrv
 
namespace makVre
{
//! \brief Forward declaration of the action menu logic class
class DtActionMenuLogic;
 
//! \brief Forward declaration of the human VR event processor class
class DtHumanVrEventProcessor;
 
//! \brief Forward declaration of the human control logic class
class DtHumanControlLogic;
 
//! \brief Type identifier constant for DtHumanVirtualRealityLogic components
//!
//! This constant defines the string identifier used to identify DtHumanVirtualRealityLogic
//! component types within the VR-Engage framework. It is used for component
//! registration, type checking, and serialization operations.
constexpr const char* DtHumanVirtualRealityLogicType = "DtHumanVirtualRealityLogic";
 
//! \brief Virtual reality logic component for the human role
//!
//! DtHumanVirtualRealityLogic manages VR-specific interaction for the human role,
//! including processing controller input, head tracking, hand tracking, and
//! providing VR-specific behavior for weapons, movement, and interaction.
//! It translates VR controller input into appropriate simulation actions.
class HUMAN_DLL DtHumanVirtualRealityLogic : public makVre::DtPlayerComponent
{
public:
   //! \brief Type alias for the controller state map
   using ControllerStateMap = makVrv::DtVirtualRealityEventManager::ControllerStateMap;
 
   //! \brief Type alias for the controller state bitfield
   using Bitfield = makVrv::DtVirtualRealityControllerState::Bitfield;
 
   //! \brief Type alias for the controller identifier
   using ControllerId = makVrv::DtVirtualRealityControllerState::ControllerId;
 
   //! \brief Type alias for 2D vector used by VR controllers
   using DtVector2f = makVrv::DtVirtualRealityControllerState::DtVector2f;
 
   //! \brief Type alias for the VR controller state
   using ControllerState = makVrv::DtVirtualRealityControllerState;
 
   //! \brief Default constructor
   DtHumanVirtualRealityLogic();
 
   //! \brief Virtual destructor
   virtual ~DtHumanVirtualRealityLogic() override;
 
   //! \brief Initializes the VR logic component
   //! \param player Pointer to the player station
   //! \param config Configuration settings for initialization
   //! \return True if initialization was successful, false otherwise
   virtual bool initialize(makVre::DtPlayerStation* player, makVre::DtInitTable& config) override;
 
   //! \brief Performs post-initialization setup
   //! \return True if post-initialization was successful, false otherwise
   virtual bool postInitialize() override;
 
   //! \brief Updates VR processing for the current frame
   //! \param dt Delta time since the last frame in seconds
   virtual void tick(double dt) override;
 
   //! \brief Cleans up resources when the component is being shut down
   virtual void shutdown() override;
 
   //! \brief Returns the component type identifier
   //! \return String identifier for this component type
   //!
   //! Returns the type identifier string for this component, which is used
   //! by the VR-Engage framework for component identification and management.
   //! The returned value matches DtHumanVirtualRealityLogicType.
   virtual const char* type() const override;
 
   //! \brief Processes controller state updates
   //! \param stateMap Map of controller states to process
   virtual void processControllerStates(const ControllerStateMap& stateMap);
 
   //! \brief Resets the head position in VR
   //!
   //! Recenters the VR view based on the current physical head position
   virtual void resetHeadPos();
 
   //! \brief Input handler for resetting head position
   //! \param val Input value (1 to trigger reset)
   //!
   //! Handles the reset head position input action from bound controls
   virtual void handleResetHeadPosInput(int val);
 
protected:
   //! \brief Structure for identifying a specific VR controller
   struct ControllerIdentifier
   {
      //! \brief Constructor
      //! \param type Controller type bitfield
      ControllerIdentifier(Bitfield type)
         : controllerType(type)
         , controllerId(ControllerState::NoId)
      {
      }
 
      Bitfield controllerType;   //!< Type of the controller
      ControllerId controllerId; //!< Unique identifier for the controller
   };
 
   //! \brief Starts VR mode
   //!
   //! Initializes and enables VR rendering and input
   virtual void startVr();
 
   //! \brief Stops VR mode
   //!
   //! Disables VR rendering and input
   virtual void stopVr();
 
   //! \brief Handles VR head position reset messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   virtual makVre::DtVreMessageResult handleResetVrHeadPos(makVre::DtVreMessage* msg);
 
   //! \brief Handles toggle mixed reality messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   virtual makVre::DtVreMessageResult handleToggleMixedReality(makVre::DtVreMessage* msg);
 
   //! \brief Handles player state enter messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   //!
   //! If incoming message is for entering the menu state, disables VR
   virtual makVre::DtVreMessageResult handleEnterPlayerState(makVre::DtVreMessage* msg);
 
   //! \brief Handles player state exit messages
   //! \param msg Pointer to the message being processed
   //! \return Message processing result
   //!
   //! If incoming message is for exiting the menu state, enables VR
   virtual makVre::DtVreMessageResult handleExitPlayerState(makVre::DtVreMessage* msg);
 
   //! \brief Finds a controller in the controller state map
   //! \param identifier [in,out] Identifier of the controller to find
   //! \param stateMap Map of controller states to search in
   //! \return Pointer to the found controller state, or nullptr if not found
   virtual const ControllerState* findController(ControllerIdentifier& identifier, const ControllerStateMap& stateMap);
 
   //! \brief Applies yaw rotation input
   //! \param val Yaw rotation value
   virtual void yaw(double val);
 
   //! \brief Pointer to the VR driver
   makVrv::DtVirtualRealityDriver* myVrDriver;
 
   //! \brief Pointer to the VR event processor
   DtHumanVrEventProcessor* myEventProcessor;
 
   //! \brief Pointer to the human control logic component
   DtHumanControlLogic* myHumanLogic;
 
   //! \brief Pointer to the action menu logic component
   makVre::DtActionMenuLogic* myMenuLogic;
 
   //! \brief Pointer to the VR overlay callback
   makVrv::DtSubmitOverlayCallback* myVrOverlay;
 
   //! \brief Flag indicating if VR is currently enabled
   bool myVrEnabled;
 
   //! \brief Flag tracking previous VR enabled state
   bool myVrWasEnabled;
 
   //! \brief Flag indicating if the player is right-handed
   bool myRightHanded;
 
   //! \brief Flag indicating if single-hand aiming is enabled
   bool mySingleHandAiming;
 
   //! \brief Flag tracking if hand motion was detected
   bool myDidHaveHandMotion;
 
   //! \brief Flag tracking if a no-motion reset was performed
   bool myDidNoHandMotionReset;
 
   //! \brief Identifier for the head/HMD controller
   ControllerIdentifier myHeadId;
 
   //! \brief Identifier for the left hand controller
   ControllerIdentifier myLeftHandId;
 
   //! \brief Identifier for the right hand controller
   ControllerIdentifier myRightHandId;
 
   //! \brief Weapon orientation override in Tait-Bryan angles
   DtTaitBryan myWeaponOverride;
 
   //! \brief Counter for frames elapsed since menu was active
   int myFramesSinceMenu;
 
   //! \brief Virtual direction pad for VR movement
   DtVirtualDpad myVirtualDpad;
 
   //! \brief Last known render order for the main channel
   int myLastMainChannelRenderOrder;
 
   //! \brief Current heading angle in radians
   //! \note Temporary variable replicating humanControlLogic until proper VR input support (VRE-3178)
   double myCurrentHeading;
 
   //! \brief Current yaw angle in radians
   //! \note Temporary variable replicating humanControlLogic until proper VR input support (VRE-3178)
   double myYaw;
 
   //! \brief Current aim yaw angle in radians
   //! \note Temporary variable replicating humanControlLogic until proper VR input support (VRE-3178)
   double myAimYaw;
 
   //! \brief Current aim pitch angle in radians
   //! \note Temporary variable replicating humanControlLogic until proper VR input support (VRE-3178)
   double myAimPitch;
 
   //! \brief Flag indicating if VR input is available
   //! \note Temporary variable replicating humanControlLogic until proper VR input support (VRE-3178)
   bool myHasVRInput;
 
   //! \brief Flag indicating if heading has been initialized
   //! \note Temporary variable replicating humanControlLogic until proper VR input support (VRE-3178)
   bool myInitializedHeading;
};
} // namespace makVre