sdlGameControllerDevice.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2025 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
 
//! \file
//! \brief Input device implementation for joystick and gamepad controllers
 
#pragma once
 
#include "vreInput/export.h"
#include "vreInput/inputDevice.h"
#include "vreInput/inputData.h"
 
#include <vector>
#include <map>
 
namespace makVre
{
//! \brief Input device implementation for joystick and gamepad controllers
//!
//! This class provides support for joystick and gamepad devices, handling
//! axis movement, button presses, and hat switch inputs. It can manage
//! multiple controllers simultaneously, differentiating them by index.
class VREINPUT_DLL DtSDLGameControllerDevice : public DtInputDevice
{
public:
   //! \brief Default constructor
   //!
   //! Initializes the joystick input device
   DtSDLGameControllerDevice();
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources owned by the joystick input device
   virtual ~DtSDLGameControllerDevice() override;
 
   //! \brief Initialize the joystick input device
   //!
   //! Sets up the joystick device with the input manager and initializes
   //! controller tracking structures.
   //!
   //! \param mgr Reference to the input manager that owns this device
   //! \return True if initialization succeeded, false otherwise
   virtual bool init(DtVreInputManager& mgr) override;
 
   //! \brief Shut down the joystick input device
   //!
   //! Releases resources and disconnects from any connected controllers
   virtual void shutdown() override;
 
   //! \brief Report the current state of all controller inputs
   //!
   //! Sends input events for the current state of all connected controllers' axes,
   //! buttons, and hat switches to initialize the input system with current values
   virtual void reportCurrentState() override;
 
   //! \brief Update method called each frame
   //!
   //! Polls connected controllers for input changes and updates internal state
   //!
   //! \param dt Delta time in seconds since the last frame
   virtual void tick(double dt) override;
 
   //! \brief Add a controller to be tracked by this device
   //!
   //! Registers a new controller with the specified index and initializes
   //! data structures to track its state
   //!
   //! \param index The index of the controller to add
   virtual void addController(int index);
 
   //! \brief Remove a controller from being tracked
   //!
   //! Unregisters a controller and removes its tracking data
   //!
   //! \param id The ID of the controller to remove
   virtual void removeController(int id);
 
   //! \brief Process input from a controller
   //!
   //! Processes input data from a controller and forwards it to the input manager
   //!
   //! \param controller The index of the controller generating the input
   //! \param type The type of input (axis, button, hat, etc.)
   //! \param id The specific input ID (button number, axis index, etc.)
   //! \param value The input value
   //! \param flags Optional flags specific to the input type
   virtual void processInput(int controller, DtInputType type, int id, float value, int flags = 0);
 
   //! \brief Process axis input from a controller
   //!
   //! Specialized handling for axis inputs, with additional processing
   //! for state tracking and dead zones
   //!
   //! \param controller The index of the controller generating the input
   //! \param id The axis index
   //! \param value The axis value
   virtual void processAxisInput(int controller, int id, int value);
 
   virtual const std::map<int, DtInputData>& getControllerData() const { return myControllerData; };
 
protected:
   //! \brief Pointer to the input manager that owns this device
   DtVreInputManager* myManager;
 
   //! \brief List of indices for currently connected controllers
   std::vector<int> myControllers;
 
   //! \brief Map of controller indices to their corresponding input data
   std::map<int, DtInputData> myControllerData;
   
   //! \brief Map tracking current position of each hat switch for each controller
   //!
   //! First key is controller index, second key is hat ID, value is position
   std::map<int, std::map<int, float>> myHatPosition;
};
 
} // namespace makVre