source-engine/game/client/in_steamcontroller.cpp

//===== Copyright 1996-2005, Valve Corporation, All rights reserved. ======//
//
// Purpose: Mouse input routines
//
// $Workfile:     $
// $Date:         $
// $NoKeywords: $
//===========================================================================//


#include "cbase.h"
#include "basehandle.h"
#include "utlvector.h"
#include "cdll_client_int.h"
#include "cdll_util.h"
#include "kbutton.h"
#include "usercmd.h"
#include "input.h"
#include "iviewrender.h"
#include "convar.h"
#include "hud.h"
#include "vgui/ISurface.h"
#include "vgui_controls/Controls.h"
#include "vgui/Cursor.h"
#include "tier0/icommandline.h"
#include "inputsystem/iinputsystem.h"
#include "inputsystem/ButtonCode.h"
#include "math.h"
#include "tier1/convar_serverbounded.h"
#include "cam_thirdperson.h"
#include "ienginevgui.h"

#if defined( _X360 )
#include "xbox/xbox_win32stubs.h"
#endif

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

#ifndef UINT64_MAX
const uint64 UINT64_MAX = 0xffffffffffffffff;
#endif

// up / down
#define	PITCH	0
// left / right
#define	YAW		1

extern const ConVar *sv_cheats;

extern ConVar cam_idealyaw;
extern ConVar cam_idealpitch;
extern ConVar thirdperson_platformer;

extern ConVar cl_forwardspeed;
extern ConVar cl_backspeed;
extern ConVar cl_sidespeed;

static ConVar sc_yaw_sensitivity( "sc_yaw_sensitivity","1.0", FCVAR_ARCHIVE , "SteamController yaw factor." );
static ConVar sc_yaw_sensitivity_default( "sc_yaw_sensitivity_default","1.0", FCVAR_NONE );

static ConVar sc_pitch_sensitivity( "sc_pitch_sensitivity","0.75", FCVAR_ARCHIVE , "SteamController pitch factor." );
static ConVar sc_pitch_sensitivity_default( "sc_pitch_sensitivity_default","0.75", FCVAR_NONE );

ConVar sc_look_sensitivity_scale( "sc_look_sensitivity_scale", "0.125", FCVAR_NONE, "Steam Controller look sensitivity global scale factor." );

void CInput::ApplySteamControllerCameraMove( QAngle& viewangles, CUserCmd *cmd, Vector2D vecPosition )
{
	//roll the view angles so roll is 0 (the HL2 assumed state) and mouse adjustments are relative to the screen.
	//Assuming roll is unchanging, we want mouse left to translate to screen left at all times (same for right, up, and down)	

	ConVarRef cl_pitchdown ( "cl_pitchdown" );
	ConVarRef cl_pitchup ( "cl_pitchup" );

	// Scale yaw and pitch inputs by sensitivity, and make sure they are within acceptable limits (important to avoid exploits, e.g. during Demoman charge we must restrict allowed yaw).
	float yaw = CAM_CapYaw( sc_yaw_sensitivity.GetFloat() * vecPosition.x );
	float pitch = CAM_CapPitch( sc_pitch_sensitivity.GetFloat() * vecPosition.y );

	if ( CAM_IsThirdPerson() )
	{
		if ( vecPosition.x )
		{
			auto vecCameraOffset = g_ThirdPersonManager.GetCameraOffsetAngles();

			// use the mouse to orbit the camera around the player, and update the idealAngle
			vecCameraOffset[YAW] -= yaw;
			cam_idealyaw.SetValue( vecCameraOffset[ YAW ] - viewangles[ YAW ] );
			viewangles[YAW] -= yaw;
		}
	}
	else
	{
		// Otherwize, use mouse to spin around vertical axis
		viewangles[YAW] -= yaw;
	}

	if ( CAM_IsThirdPerson() && thirdperson_platformer.GetInt() )
	{
		if ( vecPosition.y )
		{
			// use the mouse to orbit the camera around the player, and update the idealAngle
			auto vecCameraOffset = g_ThirdPersonManager.GetCameraOffsetAngles();
			vecCameraOffset[PITCH] += pitch;
			cam_idealpitch.SetValue( vecCameraOffset[ PITCH ] - viewangles[ PITCH ] );
		}
	}
	else
	{
		viewangles[PITCH] -= pitch;

		// Check pitch bounds
		viewangles[PITCH] = clamp ( viewangles[PITCH], -cl_pitchdown.GetFloat(), cl_pitchup.GetFloat() );
	}		

	// Finally, add mouse state to usercmd.
	// NOTE:  Does rounding to int cause any issues?  ywb 1/17/04
	cmd->mousedx = (int)vecPosition.x;
	cmd->mousedy = (int)vecPosition.y;
}

#define CONTROLLER_ACTION_FLAGS_NONE 0
#define CONTROLLER_ACTION_FLAGS_STOPS_TAUNT ( 1 << 0 )
#define CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE ( 1 << 1 )
		
struct ControllerDigitalActionToCommand
{
	const char* action;
	const char* cmd;
	int flags;
};

// Map action names to commands. Mostly these are identity mappings, but we need to handle the case of mapping to a command
// string that contains spaces (e.g. for "vote option1"), which are not allowed in action names.
static ControllerDigitalActionToCommand g_ControllerDigitalGameActions[] =
{
	{ "duck", "+duck", CONTROLLER_ACTION_FLAGS_NONE },
	{ "attack", "+attack", CONTROLLER_ACTION_FLAGS_NONE },
	{ "attack2", "+attack2", CONTROLLER_ACTION_FLAGS_NONE },
	{ "attack3", "+attack3", CONTROLLER_ACTION_FLAGS_NONE },
	{ "jump", "+jump", CONTROLLER_ACTION_FLAGS_STOPS_TAUNT },
	{ "use_action_slot_item", "+use_action_slot_item", CONTROLLER_ACTION_FLAGS_NONE },
	{ "invprev", "invprev", CONTROLLER_ACTION_FLAGS_STOPS_TAUNT|CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE },
	{ "invnext", "invnext", CONTROLLER_ACTION_FLAGS_STOPS_TAUNT|CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE },
	{ "reload", "+reload", CONTROLLER_ACTION_FLAGS_NONE },
	{ "dropitem", "dropitem", CONTROLLER_ACTION_FLAGS_STOPS_TAUNT|CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE },
	{ "changeclass", "changeclass", CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE },
	{ "changeteam", "changeteam", CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE },
	{ "open_charinfo_direct", "open_charinfo_direct", CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE },
	{ "open_charinfo_backpack", "open_charinfo_backpack", CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE },
	{ "inspect", "+inspect", CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE },
	{ "taunt", "+taunt", CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE },
	{ "voicerecord", "+voicerecord", CONTROLLER_ACTION_FLAGS_NONE },
	{ "show_quest_log", "show_quest_log", CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE },
	{ "showscores", "+showscores", CONTROLLER_ACTION_FLAGS_NONE },
	{ "callvote", "callvote", CONTROLLER_ACTION_FLAGS_NONE },
	{ "cl_trigger_first_notification", "cl_trigger_first_notification", CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE },
	{ "cl_decline_first_notification", "cl_decline_first_notification", CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE },
	{ "cl_trigger_first_notification", "vote option1", CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE },						// In here twice, because we overload this action to issue both commands
	{ "cl_decline_first_notification", "vote option2", CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE },						// In here twice, because we overload this action to issue both commands
	{ "vote_option3", "vote option3", CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE },
	{ "vote_option4", "vote option4", CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE },
	{ "vote_option5", "vote option5", CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE },
	{ "next_target", "spec_next", CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE },			// In the spectator action set only
	{ "prev_target", "spec_prev", CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE },			// In the spectator action set only
};

struct ControllerDigitalActionState {
	const char* cmd;
	ControllerDigitalActionHandle_t handle;
	bool bState;
	bool bAwaitingDebounce;
};

static ControllerDigitalActionState g_ControllerDigitalActionState[ARRAYSIZE(g_ControllerDigitalGameActions)];

static ControllerAnalogActionHandle_t g_ControllerMoveHandle;
static ControllerAnalogActionHandle_t g_ControllerCameraHandle;

bool CInput::InitializeSteamControllerGameActionSets()
{
	auto steamcontroller = g_pInputSystem->SteamControllerInterface();
	if ( !steamcontroller )
	{
		return false;
	}

	bool bGotHandle = true;

	for ( int i = 0; i < ARRAYSIZE( g_ControllerDigitalGameActions ); ++i )
	{
		const char* action = g_ControllerDigitalGameActions[i].action;
		const char* cmd = g_ControllerDigitalGameActions[i].cmd;

		ControllerDigitalActionState& state = g_ControllerDigitalActionState[i];
		state.handle = steamcontroller->GetDigitalActionHandle( action );
		bGotHandle = bGotHandle && ( state.handle != 0 );						// We're only successful if we get *all* the handles.
		state.cmd = cmd;
		state.bState = false;
		state.bAwaitingDebounce = false;
	}

	g_ControllerMoveHandle = steamcontroller->GetAnalogActionHandle( "Move" );
	g_ControllerCameraHandle = steamcontroller->GetAnalogActionHandle( "Camera" );

	if ( bGotHandle )
	{
		m_PreferredGameActionSet = GAME_ACTION_SET_MENUCONTROLS;
	}

	return bGotHandle;
}

//-----------------------------------------------------------------------------
// Purpose: SteamControllerMove -- main entry point for applying Steam Controller Movements
// Input  : *cmd - 
//-----------------------------------------------------------------------------
void CInput::SteamControllerMove( float flFrametime, CUserCmd *cmd )
{
	// Make sure we have an interface
	auto steamcontroller = g_pInputSystem->SteamControllerInterface();
	if ( !steamcontroller )
	{
		return;
	}

	// Check there is a controller connected. Do this check before we ask about handles to avoid thrashing the
	// handle query interface in the case where no controller is connected.
	uint64 nControllerHandles[STEAM_CONTROLLER_MAX_COUNT];
	int nControllerCount = steamcontroller->GetConnectedControllers( nControllerHandles );
	if ( nControllerCount <= 0 )
	{
		return;
	}

	// Initialize action handles if we haven't successfully done so already.
	if ( !m_bSteamControllerGameActionsInitialized )
	{
		m_bSteamControllerGameActionsInitialized = InitializeSteamControllerGameActionSets();
		if ( !m_bSteamControllerGameActionsInitialized )
		{
			return;
		}
	}

	g_pInputSystem->ActivateSteamControllerActionSet( m_PreferredGameActionSet );														  

	QAngle	viewangles;
	engine->GetViewAngles( viewangles );

	view->StopPitchDrift();

	bool bTaunting = m_GameActionSetFlags & GAME_ACTION_SET_FLAGS_TAUNTING;

	uint64 controller = nControllerHandles[0];
	bool bReceivedInput = false;
	for ( int i = 0; i < ARRAYSIZE( g_ControllerDigitalActionState ); ++i )
	{
		ControllerDigitalActionToCommand& cmdmap = g_ControllerDigitalGameActions[ i ];
		ControllerDigitalActionState& state = g_ControllerDigitalActionState[ i ];
		ControllerDigitalActionData_t data = steamcontroller->GetDigitalActionData( controller, state.handle );

		if ( data.bActive )
		{
			state.bAwaitingDebounce = state.bAwaitingDebounce && data.bState;

			if ( data.bState != state.bState )
			{
				bReceivedInput = true;
				if ( ( data.bState && !state.bAwaitingDebounce ) || state.cmd[0] == '+' )
				{
					char cmdbuf[128];
					Q_snprintf( cmdbuf, sizeof( cmdbuf ), "%s", state.cmd );
					if ( !data.bState )
					{
						cmdbuf[0] = '-';
					}

					engine->ClientCmd_Unrestricted( cmdbuf );

					// Hack - if we're taunting, we manufacture a stop taunt command for certain inputs (keyboard equivalent of this goes through another codepath).
					if ( bTaunting && data.bState && ( cmdmap.flags & CONTROLLER_ACTION_FLAGS_STOPS_TAUNT ) )
					{
						engine->ClientCmd_Unrestricted( "stop_taunt" );
					}
				}

				state.bState = data.bState;
			}
		}
	}

	ControllerAnalogActionData_t moveData = steamcontroller->GetAnalogActionData( controller, g_ControllerMoveHandle );

	// Clamp input to a vector no longer than 1 unit. This shouldn't happen with the physical circular constraint on the joystick, but if somehow somebody did hack their input
	// to produce longer vectors in the corners (for example), we catch that here.
	Vector2D moveDir( moveData.x, moveData.y );

	if ( moveDir.LengthSqr() > 1.0 )
	{
		moveDir.NormalizeInPlace();
	}

	// Apply forward/back movement
	if ( moveDir.y > 0.0 )
	{
		cmd->forwardmove += cl_forwardspeed.GetFloat() * moveDir.y;
	}
	else
	{
		cmd->forwardmove += cl_backspeed.GetFloat() * moveDir.y;
	}

	// Apply sidestep movement
	cmd->sidemove += cl_sidespeed.GetFloat() * moveDir.x;

	ControllerAnalogActionData_t action = steamcontroller->GetAnalogActionData( controller, g_ControllerCameraHandle );

	const float fSensitivityFactor = sc_look_sensitivity_scale.GetFloat();

	Vector2D vecMouseDelta = Vector2D( action.x, -action.y ) * fSensitivityFactor;

	if ( vecMouseDelta.Length() > 0 )
	{
		if ( !m_fCameraInterceptingMouse )
		{
			ApplySteamControllerCameraMove( viewangles, cmd, vecMouseDelta );
		}
	}

	engine->SetViewAngles( viewangles );
}

//-----------------------------------------------------------------------------
// Purpose: Sets the preferred game action set, and "debounces" controls where
// appropriate if the set has changed.
//-----------------------------------------------------------------------------
void CInput::SetPreferredGameActionSet( GameActionSet_t action_set )
{
	if ( m_PreferredGameActionSet != action_set )
	{
		// Debounce. Flag some actions as needing debounce (i.e. must see a "released" state before we'll register another "pressed" input).
		for ( int i = 0; i < ARRAYSIZE( g_ControllerDigitalActionState ); i++ )
		{
			if ( g_ControllerDigitalGameActions[i].flags & CONTROLLER_ACTION_FLAGS_NEEDS_DEBOUNCE )
			{
				g_ControllerDigitalActionState[i].bAwaitingDebounce = true;
			}
		}

		m_PreferredGameActionSet = action_set;
	}
}

GameActionSet_t CInput::GetPreferredGameActionSet()
{
	return m_PreferredGameActionSet;
}

//-----------------------------------------------------------------------------
// Purpose: Sets flags for special-case action handling
//-----------------------------------------------------------------------------
void CInput::SetGameActionSetFlags( GameActionSetFlags_t action_set_flags )
{
	m_GameActionSetFlags = action_set_flags;
}

//-----------------------------------------------------------------------------
// Purpose: Client should call this to determine if Steam Controllers are "active"
//-----------------------------------------------------------------------------
bool CInput::IsSteamControllerActive()
{
	// We're only active if the input system thinks we are AND game action sets were also initialized completely
	return m_bSteamControllerGameActionsInitialized && g_pInputSystem->IsSteamControllerActive();
}

//-----------------------------------------------------------------------------
// Purpose: Console command for launching the Steam Controller binding panel
//-----------------------------------------------------------------------------
CON_COMMAND( sc_show_binding_panel, "Launches the Steam Controller binding panel UI" )
{
	if ( g_pInputSystem )
	{
		auto steamcontroller = g_pInputSystem->SteamControllerInterface();
		if ( steamcontroller )
		{
			ControllerHandle_t controllers[STEAM_CONTROLLER_MAX_COUNT];
			int nConnected = steamcontroller->GetConnectedControllers( controllers );
			if ( nConnected > 0 )
			{
				Msg( "%d controller(s) connected. Launching binding panel for first connected controller.\n", nConnected );
				if ( !steamcontroller->ShowBindingPanel( controllers[0] ) )
				{
					Warning( "Unable to show binding panel. Steam overlay disabled, or Steam not in Big Picture mode.\n" );
				}
			}
			else
			{
				Warning( "No Steam Controllers connected.\n" );
			}
		}																									
		else
		{
			Warning( "Steam Controller interface not initialized.\n" );
		}
	}
	else
	{
		Warning( "Input system not initialized.\n" );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Console command for dumping out some Steam Controller status information
//-----------------------------------------------------------------------------
CON_COMMAND( sc_status, "Show Steam Controller status information" )
{
	if ( g_pInputSystem )
	{
		auto steamcontroller = g_pInputSystem->SteamControllerInterface();
		if ( steamcontroller )
		{
			ControllerHandle_t controllers[STEAM_CONTROLLER_MAX_COUNT];
			int nConnected = steamcontroller->GetConnectedControllers( controllers );
			if ( nConnected )
			{
				Msg( "%d Steam Controller(s) connected.\n", nConnected );
			}
			else
			{
				Warning( "No Steam Controllers(s) connected.\n" );
			}

			if ( ::input->IsSteamControllerActive() )
			{
				Msg( "Steam Controller considered active (controller connected and all action handles initialized).\n" );
			}
			else
			{
				Warning( "Steam Controller considered inactive (no controller connected, or not all action handles initialized).\n" );
			}

			auto action_set = ::input->GetPreferredGameActionSet();
			Msg( "Current action set = %d\n", action_set );

			for ( int i = 0; i < ARRAYSIZE( g_ControllerDigitalActionState ); ++i )
			{
				ControllerDigitalActionToCommand& cmdmap = g_ControllerDigitalGameActions[i];
				ControllerDigitalActionState& state = g_ControllerDigitalActionState[i];

				Msg( "Action: '%s' handle = %d\n", cmdmap.action, (int)state.handle );
			}
		}
		else
		{
			Warning( "Steam Controller interface not initialized.\n" );
		}
	}
	else
	{
		Warning( "Input system not initialized.\n" );
	}
}