Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

543 lines
18 KiB

//=========== Copyright Valve Corporation, All rights reserved. ===============//
//
// Purpose:
//=============================================================================//
#ifndef IUIINPUT_H
#define IUIINPUT_H
#ifdef _WIN32
#pragma once
#endif
#include "keycodes.h"
#include "mousecodes.h"
#include "gamepadcodes.h"
#include "tier0/platform.h"
#include "tier1/utldelegate.h"
#include "../controls/panelhandle.h"
#include "../uieventcodes.h"
#include "../iuiengine.h"
#ifdef SOURCE2_PANORAMA
#include "inputsystem/buttoncode.h"
#endif
namespace panorama
{
class CPanel2D;
class IImageSource;
class IUISettings;
// the classes of input we understand
enum EInputType
{
k_eInputNone = 0,
k_eKeyDown = 1, // raw down press
k_eKeyUp = 2, // raw release
k_eKeyChar = 3, // composited text entry from the OS
k_eMouseDown = 4,
k_eMouseUp = 5,
k_eMouseMove = 6,
k_eMouseDoubleClick = 7,
k_eMouseTripleClick = 8,
k_eMouseWheel = 9,
k_eMouseEnter = 10,
k_eMouseLeave = 11,
k_eGamePadDown = 12,
k_eGamePadUp = 13,
k_eGamePadAnalog = 14,
k_eOverlayCommand = 5000,
k_eInputTypeMaxRange = 0xFFFFFFFF // force size to 32 bits
};
enum EActiveControllerType
{
k_EActiveControllerType_None, // we aren't using a controller or we don't know to do
k_EActiveControllerType_XInput,
k_EActiveControllerType_Steam,
};
//
// structs container input type specific data
//
struct KeyData_t
{
EPanelEventSource_t m_eSource; // this needs to be the first field of the struct, since it's unioned in InputMessage_t
KeyCode m_KeyCode;
uint8 m_RepeatCount;
bool m_bFirstDown; // is this the first time this key was pressed
wchar_t m_UniChar; // unicode equivalent of this key
uint32 m_Modifiers; // alt, ctrl, etc held down?
};
struct MouseData_t
{
EPanelEventSource_t m_eSource; // this needs to be the first field of the struct, since it's unioned in InputMessage_t
MouseCode m_MouseCode;
uint32 m_Modifiers;
uint8 m_RepeatCount;
int m_Delta;
};
struct GamePadData_t
{
EPanelEventSource_t m_eSource; // this needs to be the first field of the struct, since it's unioned in InputMessage_t
GamePadCode m_GamePadCode;
uint8 m_RepeatCount; // home many times in a row we have had this button down
float m_fValue; // the analog value of the deflection if an axis
// if an analog event then these two are set for each axis value
float m_fValueX; // the analog value of the deflection along horizontal
float m_fValueY; // the analog value of the deflection along vertical
// For Steam controller analog events this value will indicate the time the users finger went down
float m_flFingerDown;
// For Steam controller analog events these values indicate the starting finger position (so you can do some basic swipe stuff)
float m_fValueXFirst;
float m_fValueYFirst;
// For Steam controller analog events this is the raw sampled coordinate without deadzoning
float m_fValueXRaw;
float m_fValueYRaw;
};
struct InputMessage_t
{
EInputType m_eInputType;
float m_flInputTime;
union
{
EPanelEventSource_t m_eSource; // where did this event originate? this is the first field of the other *Data_t structs below.
KeyData_t m_KeyData;
MouseData_t m_MouseData;
GamePadData_t m_GamePadData;
};
};
//
// A combination of event type and specific code data to mean an input event, like on key down of the A key
//
struct ActionInput_t
{
ActionInput_t()
{
m_InputType = k_eInputNone;
m_Data.m_KeyCode = KEY_NONE;
m_unModifiers = MODIFIER_NONE;
}
explicit ActionInput_t( EInputType type, KeyCode code, uint32 unModifiers, const char *pchNamespace )
{
m_InputType = type;
m_Data.m_KeyCode = code;
m_unModifiers = unModifiers;
if ( pchNamespace && pchNamespace[0] )
m_symNameSpace = pchNamespace;
}
explicit ActionInput_t( EInputType type, GamePadCode code, const char *pchNamespace )
{
m_InputType = type;
m_Data.m_GamePadCode = code;
m_unModifiers = MODIFIER_NONE;
if ( pchNamespace && pchNamespace[0] )
m_symNameSpace = pchNamespace;
}
explicit ActionInput_t( EInputType type, MouseCode code, const char *pchNamespace )
{
m_InputType = type;
m_Data.m_MouseCode = code;
m_unModifiers = MODIFIER_NONE;
if ( pchNamespace && pchNamespace[0] )
m_symNameSpace = pchNamespace;
}
ActionInput_t( InputMessage_t &msg, const char *pchNamespace )
{
m_InputType = msg.m_eInputType;
if ( pchNamespace && pchNamespace[0] )
m_symNameSpace = pchNamespace;
m_unModifiers = MODIFIER_NONE;
switch ( msg.m_eInputType )
{
default:
AssertMsg( false, "Unknown input type to ActionInput_t( InputMessage_t )" );
break;
case k_eKeyDown:
case k_eKeyUp:
case k_eKeyChar:
m_Data.m_KeyCode = msg.m_KeyData.m_KeyCode;
m_unModifiers = msg.m_KeyData.m_Modifiers;
break;
case k_eMouseDown:
case k_eMouseDoubleClick:
case k_eMouseTripleClick:
case k_eMouseUp:
case k_eMouseMove:
case k_eMouseWheel:
m_Data.m_MouseCode = msg.m_MouseData.m_MouseCode;
m_unModifiers = msg.m_MouseData.m_Modifiers;
break;
case k_eMouseEnter:
case k_eMouseLeave:
break;
case k_eGamePadDown:
case k_eGamePadUp:
case k_eGamePadAnalog:
m_Data.m_GamePadCode = msg.m_GamePadData.m_GamePadCode;
break;
}
}
// Can't ever make this not 32bits in size, see crazy comparison operators below. Also, each
// member must be exactly 32bits, not less with uninitialized data.
EInputType m_InputType;
union
{
KeyCode m_KeyCode;
GamePadCode m_GamePadCode;
MouseCode m_MouseCode;
} m_Data;
uint32 m_unModifiers;
CPanoramaSymbol m_symNameSpace;
bool operator<( const ActionInput_t &that ) const
{
if ( m_InputType != that.m_InputType )
return m_InputType < that.m_InputType;
if ( m_unModifiers != that.m_unModifiers )
return m_unModifiers < that.m_unModifiers;
// I have a namespace and you don't
if ( m_symNameSpace.IsValid() && !that.m_symNameSpace.IsValid() )
return true;
// You have a namespace and I don't
if ( that.m_symNameSpace.IsValid() && !m_symNameSpace.IsValid() )
return false;
// compare namespace if both are valid but not equal
if ( m_symNameSpace.IsValid() && that.m_symNameSpace.IsValid() && m_symNameSpace != that.m_symNameSpace )
return m_symNameSpace < that.m_symNameSpace;
// lets compare the raw code now
switch( m_InputType )
{
default:
case k_eKeyDown:
case k_eKeyUp:
case k_eKeyChar:
return m_Data.m_KeyCode < that.m_Data.m_KeyCode;
case k_eMouseDown:
case k_eMouseUp:
case k_eMouseMove:
case k_eMouseWheel:
case k_eMouseDoubleClick:
case k_eMouseTripleClick:
return m_Data.m_MouseCode < that.m_Data.m_MouseCode;
case k_eGamePadDown:
case k_eGamePadUp:
case k_eGamePadAnalog:
return m_Data.m_GamePadCode < that.m_Data.m_GamePadCode;
}
}
bool operator==( const ActionInput_t &that ) const
{
if ( m_InputType == that.m_InputType && m_unModifiers == that.m_unModifiers &&
// also if both namespace are valid and equal OR either namespace is unset (i.e "global")
( ( m_symNameSpace.IsValid() && that.m_symNameSpace.IsValid() && m_symNameSpace == that.m_symNameSpace ) || ( !m_symNameSpace.IsValid() && !that.m_symNameSpace.IsValid() ) ) )
{
switch( m_InputType )
{
default:
case k_eKeyDown:
case k_eKeyUp:
case k_eKeyChar:
return m_Data.m_KeyCode == that.m_Data.m_KeyCode;
case k_eMouseDoubleClick:
case k_eMouseTripleClick:
case k_eMouseDown:
case k_eMouseUp:
case k_eMouseMove:
case k_eMouseWheel:
return m_Data.m_MouseCode == that.m_Data.m_MouseCode;
case k_eGamePadDown:
case k_eGamePadUp:
case k_eGamePadAnalog:
return m_Data.m_GamePadCode == that.m_Data.m_GamePadCode;
}
}
return false;
}
};
// Helpers for checking modifier state
inline bool IsControlPressed( uint32 unModifiers ) { return unModifiers & MODIFIER_LCONTROL || unModifiers & MODIFIER_RCONTROL; }
inline bool IsAltPressed( uint32 unModifiers ) { return unModifiers & MODIFIER_LALT || unModifiers & MODIFIER_RALT; }
inline bool IsShiftPressed( uint32 unModifiers ) { return unModifiers & MODIFIER_LSHIFT || unModifiers & MODIFIER_RSHIFT; }
inline bool IsWinPressed( uint32 unModifiers ) { return unModifiers & MODIFIER_LWIN || unModifiers & MODIFIER_RWIN; }
//
// struct to wrap mouse move events for mouse tracked panels
//
struct MouseTrackingResults_t
{
MouseTrackingResults_t()
{
m_hPanel = k_ulInvalidPanelHandle64;
m_flX = 0.0f;
m_flY = 0.0f;
}
MouseTrackingResults_t( uint64 handle, float x, float y )
{
m_hPanel = handle;
m_flX = x;
m_flY = y;
}
uint64 m_hPanel;
float m_flX;
float m_flY;
};
//
// An interface to receive captured input
//
class IInputCapture
{
public:
// keyboard
virtual bool OnCapturedKeyDown( IUIPanel *pPanel, const KeyData_t &code ) = 0;
virtual bool OnCapturedKeyUp( IUIPanel *pPanel, const KeyData_t &code ) = 0;
virtual bool OnCapturedKeyTyped( IUIPanel *pPanel, const KeyData_t &unichar ) = 0;
// mouse
virtual bool OnCapturedMouseMove( IUIPanel *pPanel ) = 0;
virtual bool OnCapturedMouseButtonDown( IUIPanel *pPanel, const MouseData_t &code ) = 0;
virtual bool OnCapturedMouseButtonUp( IUIPanel *pPanel, const MouseData_t &code ) = 0;
virtual bool OnCapturedMouseButtonDoubleClick( IUIPanel *pPanel, const MouseData_t &code ) = 0;
virtual bool OnCapturedMouseButtonTripleClick( IUIPanel *pPanel, const MouseData_t &code ) = 0;
virtual bool OnCapturedMouseWheel( IUIPanel *pPanel, const MouseData_t &code ) = 0;
// gamepad
virtual bool OnCapturedGamePadDown( IUIPanel *pPanel, const GamePadData_t &code ) = 0;
virtual bool OnCapturedGamePadUp( IUIPanel *pPanel, const GamePadData_t &code ) = 0;
virtual bool OnCapturedGamePadAnalog( IUIPanel *pPanel, const GamePadData_t &code ) = 0;
};
class CDefaultInputCapture : public IInputCapture
{
public:
// keyboard
virtual bool OnCapturedKeyDown( panorama::IUIPanel *pPanel, const panorama::KeyData_t &code ) OVERRIDE { return false; }
virtual bool OnCapturedKeyUp( panorama::IUIPanel *pPanel, const panorama::KeyData_t &code ) OVERRIDE { return false; }
virtual bool OnCapturedKeyTyped( panorama::IUIPanel *pPanel, const panorama::KeyData_t &unichar ) OVERRIDE { return false; }
// mouse
virtual bool OnCapturedMouseMove( panorama::IUIPanel *pPanel ) OVERRIDE { return false; }
virtual bool OnCapturedMouseButtonDown( panorama::IUIPanel *pPanel, const panorama::MouseData_t &code ) OVERRIDE { return false; }
virtual bool OnCapturedMouseButtonUp( panorama::IUIPanel *pPanel, const panorama::MouseData_t &code ) OVERRIDE { return false; }
virtual bool OnCapturedMouseButtonDoubleClick( panorama::IUIPanel *pPanel, const panorama::MouseData_t &code ) OVERRIDE { return false; }
virtual bool OnCapturedMouseButtonTripleClick( panorama::IUIPanel *pPanel, const panorama::MouseData_t &code ) OVERRIDE { return false; }
virtual bool OnCapturedMouseWheel( panorama::IUIPanel *pPanel, const panorama::MouseData_t &code ) OVERRIDE { return false; }
// gamepad
virtual bool OnCapturedGamePadDown( panorama::IUIPanel *pPanel, const panorama::GamePadData_t &code ) OVERRIDE { return false; }
virtual bool OnCapturedGamePadUp( panorama::IUIPanel *pPanel, const panorama::GamePadData_t &code ) OVERRIDE { return false; }
virtual bool OnCapturedGamePadAnalog( panorama::IUIPanel *pPanel, const panorama::GamePadData_t &code ) OVERRIDE { return false; }
};
//
// Handles per top level window focus
//
class IUIWindowInput
{
public:
virtual bool InputEvent( InputMessage_t &msg, bool bNewEvent = true ) = 0;
// Receive mouse move events, in window coordinate space
virtual void OnMouseMove( float flMouseX, float flMouseY, bool bSynthesized = false ) = 0;
// current mouse coordinates and visibility
virtual void GetSurfaceMousePosition( float &x, float &y ) = 0;
virtual bool BCursorVisible() = 0;
virtual void WakeupMouseCursor() = 0;
virtual void FadeOutCursorNow() = 0;
// gamepad state
virtual int GetNumGamepadsConnected() = 0;
virtual bool BWasGamepadConnectedThisSession() = 0;
virtual bool BWasGamepadUsedThisSession() = 0;
virtual bool BWasSteamControllerConnectedThisSession() = 0;
virtual bool BWasSteamControllerUsedThisSession() = 0;
// tracking of last input type
virtual bool BWasGamepadLastInputSource() = 0;
virtual bool BWasMouseLastInputSource() = 0;
virtual bool BWasKeyboardOrMouseLastInputSource() = 0;
// Get the last input source
virtual EPanelEventSource_t GetLastPanelEventSource() = 0;
// Keyboard / mouse info
virtual bool BWasKeyboardOrMouseUsedThisSession() = 0;
virtual bool BWasMouseMovedThisSession() = 0;
// top level OS window support
virtual void GotWindowFocus() = 0;
virtual void LostWindowFocus() = 0;
virtual bool BHasWindowFocus() = 0;
// Window can temporarily disable all input, used for overlay when the game is focused, but overlay inactive
virtual bool BAllowInput( InputMessage_t &msg ) = 0;
// panel management
virtual void SetInputFocus( IUIPanel *pPanel, bool bScrollParentToFit, bool bChangeContextIfNeeded ) = 0;
virtual bool SetInputFocusContext( IUIPanel *pPanelInContext ) = 0;
virtual void PopInputContext() = 0;
virtual IUIPanel *GetInputFocusContext() = 0;
virtual IUIPanel *GetInputFocus() = 0;
virtual IUIPanel *GetMouseHover() = 0;
virtual void PanelDeleted( IUIPanel *pPanel, IUIPanel *pParent ) = 0;
// input hooks
virtual void HookPanelInput( IUIPanel *pPanel, IInputCapture *pInputCapture ) = 0;
virtual void RemovePanelInputHook( IUIPanel *pPanel, IInputCapture *pInputCapture ) = 0;
// set this panel to always (or stop) getting MouseMove events
virtual void AddMouseTrackingPanel( IUIPanel *pPanel ) = 0;
virtual void RemoveMouseTrackingPanel( IUIPanel *pPanel ) = 0;
// Are we currently inside a set input focus call
virtual bool BInSetInputFocusTraverse() = 0;
// Queue a panel focus event to occur once we finish with setting input focus
virtual void QueuePanelFocusEvent( IUIPanel *pPanel, CPanoramaSymbol symPanelEvent ) = 0;
// reset any mouse movement count as we just hid the cursor
virtual void ResetMouseMoveCount() = 0;
// Get focus panel at time of last mouse down
virtual IUIPanel *GetFocusOnLastMouseDown() = 0;
};
//
// Handles key/mouse/gamepad input and dispatches to appropriate panels
//
class IUIInput
{
public:
virtual void Initialize( IUISettings *pSettings ) = 0;
// Not ifdef'd or specific to windows. v_key ended up as a common
// denominator in lots of code (overlay as an example)
// 0x00 for error in mapping. There is no 0x00 VKEY
virtual uint16 KeyCodeToWindowsVKey( const KeyCode inKey ) = 0;
// KEY_NONE will come back on error.
virtual KeyCode WindowsVKeyToKeyCode( uint16 inKey ) = 0;
#ifdef SOURCE2_PANORAMA
virtual ButtonCode_t KeyCodeToButtonCode( const KeyCode inKey ) = 0;
virtual ButtonCode_t MouseCodeToButtonCode( const MouseCode inKey ) = 0;
#endif
// kb/mouse input
virtual bool InputEvent( InputMessage_t &msg ) = 0;
// used to capture all input
virtual void SetInputCapture( IInputCapture *pCapture ) = 0;
virtual void ReleaseInputCapture( IInputCapture *pCapture ) = 0;
virtual CUtlVector< IInputCapture * > &GetInputCapture() = 0;
// Checks whether gamepads are connected
virtual int GetNumGamepadsConnected() const = 0;
// did any gamepad have input since we last asked
virtual bool BWasGamepadOrSteamControllerActive() = 0;
// flags to tell steam controller layer which buttons to treat as mouse and not disable cursor on seeing
virtual void SetSteamPadButtonsToTreatAsMouse( uint64 ulButtonMask ) = 0;
// if a gamepad is connected then its friendly name
virtual const char *PchGamePadName() = 0;
// return true if we are emulating a gamepad using a simple joystick, so we have less input functionality available
virtual bool BEmulatingGamePadWithJoystick() = 0;
// helper for gamepad codes, returns values that are inside the deadzone for this joystick
virtual float GetDeadZoneValue( GamePadCode code ) = 0;
// translate an event into the gamepad key bound to it, XK_NULL if not bound
virtual const GamePadCode GetGamePadBindForEvent( const char *pchEvent, const IUIPanel *pFromPanel ) = 0;
// is capslock on
virtual bool BIsCapsLockOn() = 0;
// If we're trying to show help text for a controller, which type of controller is most relevant (ie., most recently
// used, exists, etc.)? You probably don't want to call this directly but instead listen for ActiveControllerTypeChanged.
virtual EActiveControllerType GetActiveControllerType() const = 0;
// Get count of actively connected Steam controllers
virtual uint32 GetSteamControllerCount() const = 0;
// Get the time a steam controller was last assigned/used
virtual float GetLastSteamControllerActiveTime() const = 0;
// Get the time a non-steam controller was last assigned/used
virtual float GetLastGamePadControllerActiveTime() const = 0;
// Get the ID of the steam controller currently sending events to the window
virtual int GetLastSteamControllerActiveIndex() const = 0;
// Pulse haptic feedback on active gamepad/steam controller if supported
virtual void PulseActiveControllerHaptic( IUIEngine::EHapticFeedbackPosition ePosition, IUIEngine::EHapticFeedbackStrength eStrength ) = 0;
// Is finger actively down on steam controller right pad? Probably means mouse emulation in use.
virtual bool BIsFingerDownOnSteamControllerRightPad() const = 0;
// Register a file path to look for keybindings
virtual void RegisterKeyBindingsFile( const char *pszFilePath ) = 0;
// Force a reload of the keybindings
virtual void ReloadKeyBindings() = 0;
// Private APIs for remote gamepad input, called on a separate network thread
virtual void RemoteGamepadAttached( int nGamepadID ) = 0;
virtual void RemoteGamepadDetached( int nGamepadID ) = 0;
virtual void SetRemoteGamepadAxis( int nGamepadID, int nAxis, int nValue ) = 0;
virtual void SetRemoteGamepadButton( int nGamepadID, int nButton, int nValue ) = 0;
// Turn off whatever (wireless) controller was last active
virtual void TurnOffActiveController() = 0;
// Get gamepad code value from textual name for config files, event code, etc
virtual panorama::GamePadCode GamePadCodeFromName( const char * pchGamePadCode ) = 0;
// Check if two gamepad codes are the 'same' button but on different vendor devices
virtual bool BIsGamePadCodeEquivalentIgnoringVendor( GamePadCode a, GamePadCode b ) = 0;
};
} // namespace panorama
#endif // IUIINPUT_H