295 lines
10 KiB
C++
295 lines
10 KiB
C++
//=============================================================================
|
|
// Copyright (C) 2003 Radical Entertainment Ltd. All rights reserved.
|
|
//
|
|
// Component: UserController
|
|
//
|
|
// Description: An input/output controller for a given player in the game. It
|
|
// bundles a number of actual controllers together to allow the
|
|
// player to use different devices (keyboard, mouse, gamepad...).
|
|
// This is the input interface between the game and the player,
|
|
// sending inputs to registered input processing classes, letting
|
|
// the player drive, move around, control the front end...
|
|
//
|
|
// This specific class is an implementation of the UserController
|
|
// class strictly for win32.
|
|
//
|
|
// History: Branched from the console UserController class.
|
|
//
|
|
//=============================================================================
|
|
|
|
#ifndef USERCONTROLLER_HPP
|
|
#define USERCONTROLLER_HPP
|
|
|
|
//========================================
|
|
// Platform check
|
|
//========================================
|
|
|
|
#ifndef RAD_WIN32
|
|
#error 'This implementation of the user controller is specific to Win32.'
|
|
#endif
|
|
|
|
//========================================
|
|
// System Includes
|
|
//========================================
|
|
|
|
#include <radcontroller.hpp>
|
|
#include <radkey.hpp>
|
|
|
|
//========================================
|
|
// Nested Includes
|
|
//========================================
|
|
|
|
#include <data/config/gameconfig.h>
|
|
#include <input/controller.h>
|
|
#include <input/button.h>
|
|
#include <input/mapper.h>
|
|
#include <input/rumbleeffect.h>
|
|
#include <input/RealController.h>
|
|
|
|
//=============================================================================
|
|
// Forward Class Declarations
|
|
//=============================================================================
|
|
|
|
class Mappable;
|
|
class Mapper;
|
|
class SteeringSpring;
|
|
class BaseDamper;
|
|
class ConstantEffect;
|
|
class WheelRumble;
|
|
|
|
//=============================================================================
|
|
// Enumerations
|
|
//=============================================================================
|
|
|
|
enum eVirtualMapSlot
|
|
{
|
|
SLOT_PRIMARY = 0,
|
|
SLOT_SECONDARY
|
|
};
|
|
|
|
#define MAX_AXIS_THRESH 1.0f
|
|
#define MIN_AXIS_THRESH -1.0f
|
|
|
|
#define MAPPING_DEADZONE 0.5f
|
|
|
|
//=============================================================================
|
|
// Interface: ButtonMappedCallback
|
|
//=============================================================================
|
|
//
|
|
// Description: Callback interface for the UserController::RemapButton method.
|
|
// Implement the method to receive notification for when a button
|
|
// has been mapped.
|
|
//
|
|
//=============================================================================
|
|
|
|
struct ButtonMappedCallback
|
|
{
|
|
virtual void OnButtonMapped( const char* InputName, eControllerType cont, int num_dirs, eDirectionType direction ) = 0;
|
|
};
|
|
|
|
//=============================================================================
|
|
// Struct: ButtonMapData
|
|
//=============================================================================
|
|
//
|
|
// Description: Internal struct for user controller.
|
|
//
|
|
//=============================================================================
|
|
|
|
struct ButtonMapData
|
|
{
|
|
ButtonMapData() : MapNext(false) {};
|
|
|
|
bool MapNext;
|
|
int map;
|
|
int virtualButton;
|
|
ButtonMappedCallback* callback;
|
|
};
|
|
|
|
//=============================================================================
|
|
// Class: UserController
|
|
//=============================================================================
|
|
//
|
|
// Description: The controller interface between the user and the game. It
|
|
// encapsulates a number of radControllers for a given player.
|
|
//
|
|
//=============================================================================
|
|
|
|
class UserController :
|
|
public IRadControllerInputPointCallback,
|
|
public GameConfigHandler
|
|
{
|
|
public:
|
|
UserController( void );
|
|
virtual ~UserController( void );
|
|
|
|
// initial set up of controller (called once at input ystem init)
|
|
virtual void Create( int id );
|
|
|
|
// set up actual controller mapping (called once at startup and prior to any time input
|
|
// connection state changes)
|
|
virtual void Initialize( RADCONTROLLER* pIController );
|
|
|
|
// release ftech controllers (called prior to input connection state change)
|
|
virtual void ReleaseRadController( void );
|
|
|
|
RealController* GetRealController( eControllerType type ) { return m_pController[type]; }
|
|
// get the index of this controller
|
|
unsigned int GetControllerId( void ) const { return m_controllerId; }
|
|
|
|
// per-frame update
|
|
void Update( unsigned timeins );
|
|
|
|
void StartForceEffects();
|
|
void StopForceEffects();
|
|
|
|
// set the current game state (to activate / deactivate appropriate logical controllerts)
|
|
void SetGameState(unsigned);
|
|
|
|
// Rumble (not yet implimented)
|
|
void SetRumble( bool bRumbleOn, bool pulse = false );
|
|
bool IsRumbleOn( void ) const;
|
|
void PulseRumble();
|
|
void ApplyEffect( RumbleEffect::Effect effect, unsigned int durationms );
|
|
void ApplyDynaEffect( RumbleEffect::DynaEffect effect, unsigned int durationms, float gain );
|
|
|
|
// connection status
|
|
bool IsConnected( void ) const;
|
|
void NotifyConnect( void );
|
|
void NotifyDisconnect( void );
|
|
|
|
// Returns the value stored by input point at index.
|
|
float GetInputValue( unsigned int index ) const;
|
|
Button* GetInputButton( unsigned int index );
|
|
|
|
// Returns the current 'real-time' value of the input point
|
|
float GetInputValueRT( unsigned int index ) const;
|
|
|
|
// Attaches an logical controller this physical controller
|
|
int RegisterMappable( Mappable* pMappable );
|
|
|
|
// Detach a logical controller
|
|
void UnregisterMappable( int handle );
|
|
void UnregisterMappable( Mappable* pMappable );
|
|
|
|
// Set up the physical-logical button mappings.
|
|
void LoadControllerMappings( void );
|
|
|
|
// return the button id from the name.
|
|
int GetIdByName( const char* pszName ) const;
|
|
|
|
SteeringSpring* GetSpring();
|
|
BaseDamper* GetDamper();
|
|
ConstantEffect* GetConstantEffect();
|
|
WheelRumble* GetWheelRumble();
|
|
WheelRumble* GetHeavyWheelRumble();
|
|
|
|
Mappable* GetMappable( unsigned int which ) { return mMappable[ which ]; };
|
|
|
|
bool IsWheel() const { return m_bIsWheel; }
|
|
|
|
// Implementation of the GameConfigHandler interface
|
|
virtual const char* GetConfigName() const;
|
|
virtual int GetNumProperties() const;
|
|
virtual void LoadDefaults();
|
|
virtual void LoadConfig( ConfigString& config );
|
|
virtual void SaveConfig( ConfigString& config );
|
|
|
|
// Public mapping functions for the user controller.
|
|
const char* GetMap( int map, int virtualKey, int& numDirs, eControllerType& cont, eDirectionType& dir ) const;
|
|
void RemapButton( int map, int VirtualButton, ButtonMappedCallback* callback );
|
|
|
|
void SetMouseLook( bool bMouseLook ) { m_bMouseLook = bMouseLook; }
|
|
void SetInvertMouseX( bool bInvertMouseX ) { m_bInvertMouseX = bInvertMouseX; }
|
|
void SetInvertMouseY( bool bInvertMouseY ) { m_bInvertMouseY = bInvertMouseY; }
|
|
void SetForceFeedback( bool bForceFeedback ) { m_bForceFeedback = bForceFeedback; }
|
|
void SetTutorialDisabled( bool bDisabled ) { m_bTutorialDisabled = bDisabled; }
|
|
void SetMouseSensitivityX( float fValue ) { m_fMouseSensitivityX = fValue; }
|
|
void SetMouseSensitivityY( float fValue ) { m_fMouseSensitivityY = fValue; }
|
|
void SetWheelSensitivityX( float fValue ) { m_fWheelSensitivityX = fValue; }
|
|
void SetWheelSensitivityY( float fValue ) { m_fWheelSensitivityY = fValue; }
|
|
|
|
bool IsMouseLookOn() const { return m_bMouseLook; }
|
|
bool IsMouseXInverted() const { return m_bInvertMouseX; }
|
|
bool IsMouseYInverted() const { return m_bInvertMouseY; }
|
|
bool IsForceFeedbackOn() const { return m_bForceFeedback; }
|
|
bool IsTutorialDisabled() const { return m_bTutorialDisabled; }
|
|
|
|
float GetMouseSensitivityX() const { return m_fMouseSensitivityX; }
|
|
float GetMouseSensitivityY() const { return m_fMouseSensitivityY; }
|
|
float GetWheelSensitivityX() const { return m_fWheelSensitivityX; }
|
|
float GetWheelSensitivityY() const { return m_fWheelSensitivityY; }
|
|
|
|
protected:
|
|
|
|
// These register our callbacks with the RadControllers.
|
|
void RegisterInputPoints();
|
|
void RegisterInputPoint( eControllerType type, int inputpoint );
|
|
|
|
// Callback for when keys/inputs are pressed by the user.
|
|
void OnControllerInputPointChange( unsigned int buttonId, float value );
|
|
|
|
// These process input point values as received by the input point callback.
|
|
int DeriveDirectionValues( eControllerType type, int dxKey, float value, float* dir_values );
|
|
void SetButtonValue( unsigned int virtualButton, float value, bool sticky );
|
|
|
|
// Needed to get mouse axes to function properly
|
|
void ResetMouseAxes();
|
|
|
|
// Private mapping functions for the user controller.
|
|
void SetMap( int map, int virtualKey, eControllerType cont, int dxKey, eDirectionType dir = DIR_UP );
|
|
bool GetMap( int map, int virtualKey, eControllerType& cont, int& dxKey, eDirectionType& dir ) const;
|
|
void Remap( eControllerType cont, int dxKey, float* dvalues, int directions );
|
|
void ClearMappings();
|
|
void LoadFEMappings();
|
|
|
|
private:
|
|
|
|
int m_controllerId;
|
|
bool mIsConnected;
|
|
|
|
unsigned mGameState;
|
|
bool mbInputPointsRegistered;
|
|
|
|
RealController* m_pController[ NUM_CONTROLLERTYPES ];
|
|
|
|
SteeringSpring* m_pSteeringSpring;
|
|
BaseDamper* m_pSteeringDamper;
|
|
ConstantEffect* m_pConstantEffect;
|
|
WheelRumble* m_pWheelRumble;
|
|
WheelRumble* m_pHeavyWheelRumble;
|
|
|
|
Mappable* mMappable[ Input::MaxMappables ];
|
|
|
|
// Virtual mapping data.
|
|
Mapper mVirtualMap[ Input::MaxVirtualMappings ];
|
|
ButtonMapData mMapData;
|
|
|
|
// Button data.
|
|
int mNumButtons;
|
|
Button mButtonArray[ Input::MaxPhysicalButtons ];
|
|
radKey mButtonNames[ Input::MaxPhysicalButtons ];
|
|
float mButtonDeadZones[ Input::MaxPhysicalButtons ];
|
|
bool mButtonSticky[ Input::MaxPhysicalButtons ];
|
|
|
|
bool mKeyboardBack;
|
|
|
|
bool mbIsRumbleOn;
|
|
bool m_bIsWheel;
|
|
RumbleEffect mRumbleEffect;
|
|
|
|
bool m_bMouseLook,
|
|
m_bInvertMouseX,
|
|
m_bInvertMouseY,
|
|
m_bForceFeedback;
|
|
bool m_bTutorialDisabled;
|
|
|
|
float m_fMouseSensitivityX,
|
|
m_fMouseSensitivityY,
|
|
m_fWheelSensitivityX, // The wheel
|
|
m_fWheelSensitivityY; // The pedals
|
|
|
|
int mResetMouseCounter[3]; // Hack needed for proper mouse inputs.
|
|
};
|
|
|
|
#endif
|