#include "client.h"
#include "system/lirc.h"

Classes
struct	in_state_t

struct	kbutton_s

Typedefs
typedef struct kbutton_s	kbutton_t

Functions
const inputAPI_t *	IN_GetAPI ()

static qboolean	IN_GetCurrentGrab (void)

void	IN_Activate (void)

static void	IN_Restart_f (void)

void	IN_Frame (void)

void	IN_WarpMouse (int x, int y)

void	IN_Shutdown (void)

static void	in_changed_hard (cvar_t *self)

static void	in_changed_soft (cvar_t *self)

void	IN_Init (void)

static void	KeyDown (kbutton_t *b)

static void	KeyUp (kbutton_t *b)

static void	KeyClear (kbutton_t *b)

static void	IN_KLookDown (void)

static void	IN_KLookUp (void)

static void	IN_UpDown (void)

static void	IN_UpUp (void)

static void	IN_DownDown (void)

static void	IN_DownUp (void)

static void	IN_LeftDown (void)

static void	IN_LeftUp (void)

static void	IN_RightDown (void)

static void	IN_RightUp (void)

static void	IN_ForwardDown (void)

static void	IN_ForwardUp (void)

static void	IN_BackDown (void)

static void	IN_BackUp (void)

static void	IN_LookupDown (void)

static void	IN_LookupUp (void)

static void	IN_LookdownDown (void)

static void	IN_LookdownUp (void)

static void	IN_MoveleftDown (void)

static void	IN_MoveleftUp (void)

static void	IN_MoverightDown (void)

static void	IN_MoverightUp (void)

static void	IN_SpeedDown (void)

static void	IN_SpeedUp (void)

static void	IN_StrafeDown (void)

static void	IN_StrafeUp (void)

static void	IN_AttackDown (void)

static void	IN_AttackUp (void)

static void	IN_UseDown (void)

static void	IN_UseUp (void)

static void	IN_Impulse (void)

static void	IN_CenterView (void)

static void	IN_MLookDown (void)

static void	IN_MLookUp (void)

static float	CL_KeyState (kbutton_t *key)

static void	CL_MouseMove (void)

static void	CL_AdjustAngles (int msec)

static void	CL_BaseMove (vec3_t move)

static void	CL_ClampSpeed (vec3_t move)

static void	CL_ClampPitch (void)

void	CL_UpdateCmd (int msec)

static void	m_autosens_changed (cvar_t *self)

void	CL_RegisterInput (void)

void	CL_FinalizeCmd (void)

static qboolean	ready_to_send (void)

static qboolean	ready_to_send_hacked (void)

static void	CL_SendDefaultCmd (void)

static void	CL_SendBatchedCmd (void)

static void	CL_SendKeepAlive (void)

static void	CL_SendUserinfo (void)

void	CL_SendCmd (void)

Variables
static cvar_t *	cl_nodelta

static cvar_t *	cl_maxpackets

static cvar_t *	cl_packetdup

static cvar_t *	cl_fuzzhack

static cvar_t *	cl_instantpacket

static cvar_t *	cl_batchcmds

static cvar_t *	m_filter

cvar_t *	m_accel

cvar_t *	m_autosens

static cvar_t *	cl_upspeed

static cvar_t *	cl_forwardspeed

static cvar_t *	cl_sidespeed

static cvar_t *	cl_yawspeed

static cvar_t *	cl_pitchspeed

static cvar_t *	cl_run

static cvar_t *	cl_anglespeedkey

static cvar_t *	freelook

static cvar_t *	lookspring

static cvar_t *	lookstrafe

cvar_t *	sensitivity

cvar_t *	m_pitch

cvar_t *	m_invert

cvar_t *	m_yaw

static cvar_t *	m_forward

static cvar_t *	m_side

static in_state_t	input

static cvar_t *	in_enable

static cvar_t *	in_grab

static kbutton_t	in_klook

static kbutton_t	in_left

static kbutton_t	in_right

static kbutton_t	in_forward

static kbutton_t	in_back

static kbutton_t	in_lookup

static kbutton_t	in_lookdown

static kbutton_t	in_moveleft

static kbutton_t	in_moveright

static kbutton_t	in_strafe

static kbutton_t	in_speed

static kbutton_t	in_use

static kbutton_t	in_attack

static kbutton_t	in_up

static kbutton_t	in_down

static int	in_impulse

static qboolean	in_mlooking

float	autosens_x

float	autosens_y

Typedef Documentation

◆ kbutton_t

typedef struct kbutton_s kbutton_t

Function Documentation

◆ CL_AdjustAngles()

static void CL_AdjustAngles ( int msec )

static

Definition at line 566 of file input.c.

 {
     float speed;
  
     if (in_speed.state & 1)
         speed = msec * cl_anglespeedkey->value * 0.001f;
     else
         speed = msec * 0.001f;
  
     if (!(in_strafe.state & 1)) {
         cl.viewangles[YAW] -= speed * cl_yawspeed->value * CL_KeyState(&in_right);
         cl.viewangles[YAW] += speed * cl_yawspeed->value * CL_KeyState(&in_left);
     }
     if (in_klook.state & 1) {
         cl.viewangles[PITCH] -= speed * cl_pitchspeed->value * CL_KeyState(&in_forward);
         cl.viewangles[PITCH] += speed * cl_pitchspeed->value * CL_KeyState(&in_back);
     }
  
     cl.viewangles[PITCH] -= speed * cl_pitchspeed->value * CL_KeyState(&in_lookup);
     cl.viewangles[PITCH] += speed * cl_pitchspeed->value * CL_KeyState(&in_lookdown);
 }

Referenced by CL_UpdateCmd().

◆ CL_BaseMove()

static void CL_BaseMove ( vec3_t move )

static

Definition at line 595 of file input.c.

 {
     if (in_strafe.state & 1) {
         move[1] += cl_sidespeed->value * CL_KeyState(&in_right);
         move[1] -= cl_sidespeed->value * CL_KeyState(&in_left);
     }
  
     move[1] += cl_sidespeed->value * CL_KeyState(&in_moveright);
     move[1] -= cl_sidespeed->value * CL_KeyState(&in_moveleft);
  
     move[2] += cl_upspeed->value * CL_KeyState(&in_up);
     move[2] -= cl_upspeed->value * CL_KeyState(&in_down);
  
     if (!(in_klook.state & 1)) {
         move[0] += cl_forwardspeed->value * CL_KeyState(&in_forward);
         move[0] -= cl_forwardspeed->value * CL_KeyState(&in_back);
     }
  
 // adjust for speed key / running
     if ((in_speed.state & 1) ^ cl_run->integer) {
         VectorScale(move, 2, move);
     }
 }

Referenced by CL_FinalizeCmd(), and CL_UpdateCmd().

◆ CL_ClampPitch()

static void CL_ClampPitch ( void )

static

Definition at line 628 of file input.c.

 {
     float pitch;
  
     pitch = SHORT2ANGLE(cl.frame.ps.pmove.delta_angles[PITCH]);
     if (pitch > 180)
         pitch -= 360;
  
     if (cl.viewangles[PITCH] + pitch < -360)
         cl.viewangles[PITCH] += 360; // wrapped
     if (cl.viewangles[PITCH] + pitch > 360)
         cl.viewangles[PITCH] -= 360; // wrapped
  
     if (cl.viewangles[PITCH] + pitch > 89)
         cl.viewangles[PITCH] = 89 - pitch;
     if (cl.viewangles[PITCH] + pitch < -89)
         cl.viewangles[PITCH] = -89 - pitch;
 }

Referenced by CL_UpdateCmd().

◆ CL_ClampSpeed()

static void CL_ClampSpeed ( vec3_t move )

static

Definition at line 619 of file input.c.

 {
     float speed = cl.pmp.maxspeed;
  
     clamp(move[0], -speed, speed);
     clamp(move[1], -speed, speed);
     clamp(move[2], -speed, speed);
 }

Referenced by CL_FinalizeCmd(), and CL_UpdateCmd().

◆ CL_FinalizeCmd()

void CL_FinalizeCmd ( void )

Definition at line 790 of file input.c.

 {
     vec3_t move;
  
     // command buffer ticks in sync with cl_maxfps
     if (cmd_buffer.waitCount > 0) {
         cmd_buffer.waitCount--;
     }
     if (cl_cmdbuf.waitCount > 0) {
         cl_cmdbuf.waitCount--;
     }
  
     if (cls.state != ca_active) {
         return; // not talking to a server
     }
  
     if (sv_paused->integer) {
         return;
     }
  
 //
 // figure button bits
 //
     if (in_attack.state & 3)
         cl.cmd.buttons |= BUTTON_ATTACK;
     if (in_use.state & 3)
         cl.cmd.buttons |= BUTTON_USE;
  
     in_attack.state &= ~2;
     in_use.state &= ~2;
  
     if (cls.key_dest == KEY_GAME && Key_AnyKeyDown()) {
         cl.cmd.buttons |= BUTTON_ANY;
     }
  
     if (cl.cmd.msec > 250) {
         cl.cmd.msec = 100;        // time was unreasonable
     }
  
     // rebuild the movement vector
     VectorClear(move);
  
     // get basic movement from keyboard
     CL_BaseMove(move);
  
     // add mouse forward/side movement
     move[0] += cl.mousemove[0];
     move[1] += cl.mousemove[1];
  
     // clamp to server defined max speed
     CL_ClampSpeed(move);
  
     // store the movement vector
     cl.cmd.forwardmove = move[0];
     cl.cmd.sidemove = move[1];
     cl.cmd.upmove = move[2];
  
     // clear all states
     cl.mousemove[0] = 0;
     cl.mousemove[1] = 0;
  
     KeyClear(&in_right);
     KeyClear(&in_left);
  
     KeyClear(&in_moveright);
     KeyClear(&in_moveleft);
  
     KeyClear(&in_up);
     KeyClear(&in_down);
  
     KeyClear(&in_forward);
     KeyClear(&in_back);
  
     KeyClear(&in_lookup);
     KeyClear(&in_lookdown);
  
     cl.cmd.impulse = in_impulse;
     in_impulse = 0;
  
     // save this command off for prediction
     cl.cmdNumber++;
     cl.cmds[cl.cmdNumber & CMD_MASK] = cl.cmd;
  
     // clear pending cmd
     memset(&cl.cmd, 0, sizeof(cl.cmd));
 }

Referenced by CL_Frame().

◆ CL_KeyState()

static float CL_KeyState ( kbutton_t * key )

static

Definition at line 468 of file input.c.

 {
     unsigned msec = key->msec;
     float val;
  
     if (key->state & 1) {
         // still down
         if (com_eventTime > key->downtime) {
             msec += com_eventTime - key->downtime;
         }
     }
  
     // special case for instant packet
     if (!cl.cmd.msec) {
         return (float)(key->state & 1);
     }
  
     val = (float)msec / cl.cmd.msec;
  
     return clamp(val, 0, 1);
 }

Referenced by CL_AdjustAngles(), and CL_BaseMove().

◆ CL_MouseMove()

static void CL_MouseMove ( void )

static

Definition at line 500 of file input.c.

 {
     int dx, dy;
     float mx, my;
     float speed;
  
     if (!input.api.GetMotion) {
         return;
     }
     if (cls.key_dest & (KEY_MENU | KEY_CONSOLE)) {
         return;
     }
     if (!input.api.GetMotion(&dx, &dy)) {
         return;
     }
  
     if (m_filter->integer) {
         mx = (dx + input.old_dx) * 0.5f;
         my = (dy + input.old_dy) * 0.5f;
     } else {
         mx = dx;
         my = dy;
     }
  
     input.old_dx = dx;
     input.old_dy = dy;
  
     if (!mx && !my) {
         return;
     }
  
     Cvar_ClampValue(m_accel, 0, 1);
  
     speed = sqrt(mx * mx + my * my);
     speed = sensitivity->value + speed * m_accel->value;
  
     mx *= speed;
     my *= speed;
  
     if (m_autosens->integer) {
         mx *= cl.fov_x * autosens_x;
         my *= cl.fov_y * autosens_y;
     }
  
 // add mouse X/Y movement
     if ((in_strafe.state & 1) || (lookstrafe->integer && !in_mlooking)) {
         cl.mousemove[1] += m_side->value * mx;
     } else {
         cl.viewangles[YAW] -= m_yaw->value * mx;
     }
  
     if ((in_mlooking || freelook->integer) && !(in_strafe.state & 1)) {
         cl.viewangles[PITCH] += m_pitch->value * my * (m_invert->integer ? -1.f : 1.f);
     } else {
         cl.mousemove[0] -= m_forward->value * my;
     }
 }

Referenced by CL_UpdateCmd().

◆ CL_RegisterInput()

void CL_RegisterInput ( void )

Definition at line 707 of file input.c.

 {
     Cmd_AddCommand("centerview", IN_CenterView);
  
     Cmd_AddCommand("+moveup", IN_UpDown);
     Cmd_AddCommand("-moveup", IN_UpUp);
     Cmd_AddCommand("+movedown", IN_DownDown);
     Cmd_AddCommand("-movedown", IN_DownUp);
     Cmd_AddCommand("+left", IN_LeftDown);
     Cmd_AddCommand("-left", IN_LeftUp);
     Cmd_AddCommand("+right", IN_RightDown);
     Cmd_AddCommand("-right", IN_RightUp);
     Cmd_AddCommand("+forward", IN_ForwardDown);
     Cmd_AddCommand("-forward", IN_ForwardUp);
     Cmd_AddCommand("+back", IN_BackDown);
     Cmd_AddCommand("-back", IN_BackUp);
     Cmd_AddCommand("+lookup", IN_LookupDown);
     Cmd_AddCommand("-lookup", IN_LookupUp);
     Cmd_AddCommand("+lookdown", IN_LookdownDown);
     Cmd_AddCommand("-lookdown", IN_LookdownUp);
     Cmd_AddCommand("+strafe", IN_StrafeDown);
     Cmd_AddCommand("-strafe", IN_StrafeUp);
     Cmd_AddCommand("+moveleft", IN_MoveleftDown);
     Cmd_AddCommand("-moveleft", IN_MoveleftUp);
     Cmd_AddCommand("+moveright", IN_MoverightDown);
     Cmd_AddCommand("-moveright", IN_MoverightUp);
     Cmd_AddCommand("+speed", IN_SpeedDown);
     Cmd_AddCommand("-speed", IN_SpeedUp);
     Cmd_AddCommand("+attack", IN_AttackDown);
     Cmd_AddCommand("-attack", IN_AttackUp);
     Cmd_AddCommand("+use", IN_UseDown);
     Cmd_AddCommand("-use", IN_UseUp);
     Cmd_AddCommand("impulse", IN_Impulse);
     Cmd_AddCommand("+klook", IN_KLookDown);
     Cmd_AddCommand("-klook", IN_KLookUp);
     Cmd_AddCommand("+mlook", IN_MLookDown);
     Cmd_AddCommand("-mlook", IN_MLookUp);
  
     Cmd_AddCommand("in_restart", IN_Restart_f);
  
     cl_nodelta = Cvar_Get("cl_nodelta", "0", 0);
     cl_maxpackets = Cvar_Get("cl_maxpackets", "30", 0);
     cl_fuzzhack = Cvar_Get("cl_fuzzhack", "0", 0);
     cl_packetdup = Cvar_Get("cl_packetdup", "1", 0);
 #ifdef _DEBUG
     cl_showpackets = Cvar_Get("cl_showpackets", "0", 0);
 #endif
     cl_instantpacket = Cvar_Get("cl_instantpacket", "1", 0);
     cl_batchcmds = Cvar_Get("cl_batchcmds", "1", 0);
  
     cl_upspeed = Cvar_Get("cl_upspeed", "200", 0);
     cl_forwardspeed = Cvar_Get("cl_forwardspeed", "200", 0);
     cl_sidespeed = Cvar_Get("cl_sidespeed", "200", 0);
     cl_yawspeed = Cvar_Get("cl_yawspeed", "140", 0);
     cl_pitchspeed = Cvar_Get("cl_pitchspeed", "150", CVAR_CHEAT);
     cl_anglespeedkey = Cvar_Get("cl_anglespeedkey", "1.5", CVAR_CHEAT);
     cl_run = Cvar_Get("cl_run", "1", CVAR_ARCHIVE);
  
     freelook = Cvar_Get("freelook", "1", CVAR_ARCHIVE);
     lookspring = Cvar_Get("lookspring", "0", CVAR_ARCHIVE);
     lookstrafe = Cvar_Get("lookstrafe", "0", CVAR_ARCHIVE);
     sensitivity = Cvar_Get("sensitivity", "3", CVAR_ARCHIVE);
  
     m_pitch = Cvar_Get("m_pitch", "0.022", CVAR_ARCHIVE);
     m_invert = Cvar_Get("m_invert", "0", CVAR_ARCHIVE);
     m_yaw = Cvar_Get("m_yaw", "0.022", 0);
     m_forward = Cvar_Get("m_forward", "1", 0);
     m_side = Cvar_Get("m_side", "1", 0);
     m_filter = Cvar_Get("m_filter", "0", 0);
     m_accel = Cvar_Get("m_accel", "0", 0);
     m_autosens = Cvar_Get("m_autosens", "0", 0);
     m_autosens->changed = m_autosens_changed;
     m_autosens_changed(m_autosens);
 }

Referenced by CL_InitLocal().

◆ CL_SendBatchedCmd()

static void CL_SendBatchedCmd ( void )

static

Definition at line 1009 of file input.c.

 {
     int i, j, seq, bits q_unused;
     int numCmds, numDups;
     int totalCmds, totalMsec;
     size_t cursize q_unused;
     usercmd_t *cmd, *oldcmd;
     client_history_t *history, *oldest;
     byte *patch;
  
     // see if we are ready to send this packet
     if (!ready_to_send()) {
         return;
     }
  
     // archive this packet
     seq = cls.netchan->outgoing_sequence;
     history = &cl.history[seq & CMD_MASK];
     history->cmdNumber = cl.cmdNumber;
     history->sent = cls.realtime;    // for ping calculation
     history->rcvd = 0;
  
     cl.lastTransmitTime = cls.realtime;
     cl.lastTransmitCmdNumber = cl.cmdNumber;
     cl.lastTransmitCmdNumberReal = cl.cmdNumber;
  
     // begin a client move command
     patch = SZ_GetSpace(&msg_write, 1);
  
     // let the server know what the last frame we
     // got was, so the next message can be delta compressed
     if (cl_nodelta->integer || !cl.frame.valid /*|| cls.demowaiting*/) {
         *patch = clc_move_nodelta; // no compression
     } else {
         *patch = clc_move_batched;
         MSG_WriteLong(cl.frame.number);
     }
  
     Cvar_ClampInteger(cl_packetdup, 0, MAX_PACKET_FRAMES - 1);
     numDups = cl_packetdup->integer;
  
     *patch |= numDups << SVCMD_BITS;
  
     // send lightlevel
     MSG_WriteByte(cl.lightlevel);
  
     // send this and the previous cmds in the message, so
     // if the last packet was dropped, it can be recovered
     oldcmd = NULL;
     totalCmds = 0;
     totalMsec = 0;
     for (i = seq - numDups; i <= seq; i++) {
         oldest = &cl.history[(i - 1) & CMD_MASK];
         history = &cl.history[i & CMD_MASK];
  
         numCmds = history->cmdNumber - oldest->cmdNumber;
         if (numCmds >= MAX_PACKET_USERCMDS) {
             Com_WPrintf("%s: MAX_PACKET_USERCMDS exceeded\n", __func__);
             SZ_Clear(&msg_write);
             break;
         }
         totalCmds += numCmds;
         MSG_WriteBits(numCmds, 5);
         for (j = oldest->cmdNumber + 1; j <= history->cmdNumber; j++) {
             cmd = &cl.cmds[j & CMD_MASK];
             totalMsec += cmd->msec;
             bits = MSG_WriteDeltaUsercmd_Enhanced(oldcmd, cmd, cls.protocolVersion);
 #ifdef _DEBUG
             if (cl_showpackets->integer == 3) {
                 MSG_ShowDeltaUsercmdBits_Enhanced(bits);
             }
 #endif
             oldcmd = cmd;
         }
     }
  
     P_FRAMES++;
  
     //
     // deliver the message
     //
     cursize = cls.netchan->Transmit(cls.netchan, msg_write.cursize, msg_write.data, 1);
 #ifdef _DEBUG
     if (cl_showpackets->integer == 1) {
         Com_Printf("%"PRIz"(%i) ", cursize, totalCmds);
     } else if (cl_showpackets->integer == 2) {
         Com_Printf("%"PRIz"(%i) ", cursize, totalMsec);
     } else if (cl_showpackets->integer == 3) {
         Com_Printf(" | ");
     }
 #endif
  
     SZ_Clear(&msg_write);
 }

Referenced by CL_SendCmd().

◆ CL_SendCmd()

void CL_SendCmd ( void )

Definition at line 1166 of file input.c.

 {
     if (cls.state < ca_connected) {
         return; // not talking to a server
     }
  
     // generate usercmds while playing a demo,
     // but do not send them
     if (!cls.netchan) {
         return;
     }
  
     if (cls.state != ca_active || sv_paused->integer) {
         // send a userinfo update if needed
         CL_SendUserinfo();
  
         // just keepalive or update reliable
         if (cls.netchan->ShouldUpdate(cls.netchan)) {
             CL_SendKeepAlive();
         }
  
         cl.sendPacketNow = qfalse;
         return;
     }
  
     // are there any new usercmds to send after all?
     if (cl.lastTransmitCmdNumber == cl.cmdNumber) {
         return; // nothing to send
     }
  
     // send a userinfo update if needed
     CL_SendUserinfo();
  
     if (cls.serverProtocol == PROTOCOL_VERSION_Q2PRO && cl_batchcmds->integer) {
         CL_SendBatchedCmd();
     } else {
         CL_SendDefaultCmd();
     }
  
     cl.sendPacketNow = qfalse;
 }

Referenced by CL_Frame().

◆ CL_SendDefaultCmd()

static void CL_SendDefaultCmd ( void )

static

Definition at line 924 of file input.c.

 {
     size_t cursize q_unused, checksumIndex;
     usercmd_t *cmd, *oldcmd;
     client_history_t *history;
  
     // archive this packet
     history = &cl.history[cls.netchan->outgoing_sequence & CMD_MASK];
     history->cmdNumber = cl.cmdNumber;
     history->sent = cls.realtime;    // for ping calculation
     history->rcvd = 0;
  
     cl.lastTransmitCmdNumber = cl.cmdNumber;
  
     // see if we are ready to send this packet
     if (!ready_to_send_hacked()) {
         cls.netchan->outgoing_sequence++; // just drop the packet
         return;
     }
  
     cl.lastTransmitTime = cls.realtime;
     cl.lastTransmitCmdNumberReal = cl.cmdNumber;
  
     // begin a client move command
     MSG_WriteByte(clc_move);
  
     // save the position for a checksum byte
     checksumIndex = 0;
     if (cls.serverProtocol <= PROTOCOL_VERSION_DEFAULT) {
         checksumIndex = msg_write.cursize;
         SZ_GetSpace(&msg_write, 1);
     }
  
     // let the server know what the last frame we
     // got was, so the next message can be delta compressed
     if (cl_nodelta->integer || !cl.frame.valid /*|| cls.demowaiting*/) {
         MSG_WriteLong(-1);   // no compression
     } else {
         MSG_WriteLong(cl.frame.number);
     }
  
     // send this and the previous cmds in the message, so
     // if the last packet was dropped, it can be recovered
     cmd = &cl.cmds[(cl.cmdNumber - 2) & CMD_MASK];
     MSG_WriteDeltaUsercmd(NULL, cmd, cls.protocolVersion);
     MSG_WriteByte(cl.lightlevel);
     oldcmd = cmd;
  
     cmd = &cl.cmds[(cl.cmdNumber - 1) & CMD_MASK];
     MSG_WriteDeltaUsercmd(oldcmd, cmd, cls.protocolVersion);
     MSG_WriteByte(cl.lightlevel);
     oldcmd = cmd;
  
     cmd = &cl.cmds[cl.cmdNumber & CMD_MASK];
     MSG_WriteDeltaUsercmd(oldcmd, cmd, cls.protocolVersion);
     MSG_WriteByte(cl.lightlevel);
  
     if (cls.serverProtocol <= PROTOCOL_VERSION_DEFAULT) {
         // calculate a checksum over the move commands
         msg_write.data[checksumIndex] = COM_BlockSequenceCRCByte(
                                             msg_write.data + checksumIndex + 1,
                                             msg_write.cursize - checksumIndex - 1,
                                             cls.netchan->outgoing_sequence);
     }
  
     P_FRAMES++;
  
     //
     // deliver the message
     //
     cursize = cls.netchan->Transmit(cls.netchan, msg_write.cursize, msg_write.data, 1);
 #ifdef _DEBUG
     if (cl_showpackets->integer) {
         Com_Printf("%"PRIz" ", cursize);
     }
 #endif
  
     SZ_Clear(&msg_write);
 }

Referenced by CL_SendCmd().

◆ CL_SendKeepAlive()

static void CL_SendKeepAlive ( void )

static

Definition at line 1104 of file input.c.

 {
     client_history_t *history;
     size_t cursize q_unused;
  
     // archive this packet
     history = &cl.history[cls.netchan->outgoing_sequence & CMD_MASK];
     history->cmdNumber = cl.cmdNumber;
     history->sent = cls.realtime;    // for ping calculation
     history->rcvd = 0;
  
     cl.lastTransmitTime = cls.realtime;
     cl.lastTransmitCmdNumber = cl.cmdNumber;
     cl.lastTransmitCmdNumberReal = cl.cmdNumber;
  
     cursize = cls.netchan->Transmit(cls.netchan, 0, NULL, 1);
 #ifdef _DEBUG
     if (cl_showpackets->integer) {
         Com_Printf("%"PRIz" ", cursize);
     }
 #endif
 }

Referenced by CL_SendCmd().

◆ CL_SendUserinfo()

static void CL_SendUserinfo ( void )

static

Definition at line 1127 of file input.c.

 {
     char userinfo[MAX_INFO_STRING];
     cvar_t *var;
     int i;
  
     if (!cls.userinfo_modified) {
         return;
     }
  
     if (cls.userinfo_modified == MAX_PACKET_USERINFOS) {
         size_t len = Cvar_BitInfo(userinfo, CVAR_USERINFO);
         Com_DDPrintf("%s: %u: full update\n", __func__, com_framenum);
         MSG_WriteByte(clc_userinfo);
         MSG_WriteData(userinfo, len + 1);
         MSG_FlushTo(&cls.netchan->message);
     } else if (cls.serverProtocol == PROTOCOL_VERSION_Q2PRO) {
         Com_DDPrintf("%s: %u: %d updates\n", __func__, com_framenum,
                      cls.userinfo_modified);
         for (i = 0; i < cls.userinfo_modified; i++) {
             var = cls.userinfo_updates[i];
             MSG_WriteByte(clc_userinfo_delta);
             MSG_WriteString(var->name);
             if (var->flags & CVAR_USERINFO) {
                 MSG_WriteString(var->string);
             } else {
                 // no longer in userinfo
                 MSG_WriteString(NULL);
             }
         }
         MSG_FlushTo(&cls.netchan->message);
     } else {
         Com_WPrintf("%s: update count is %d, should never happen.\n",
                     __func__, cls.userinfo_modified);
     }
  
     cls.userinfo_modified = 0;
 }

Referenced by CL_SendCmd().

◆ CL_UpdateCmd()

void CL_UpdateCmd ( int msec )

Definition at line 655 of file input.c.

 {
     VectorClear(cl.localmove);
  
     if (sv_paused->integer) {
         return;
     }
  
     // add to milliseconds of time to apply the move
     cl.cmd.msec += msec;
  
     // adjust viewangles
     CL_AdjustAngles(msec);
  
     // get basic movement from keyboard
     CL_BaseMove(cl.localmove);
  
     // allow mice to add to the move
     CL_MouseMove();
  
     // add accumulated mouse forward/side movement
     cl.localmove[0] += cl.mousemove[0];
     cl.localmove[1] += cl.mousemove[1];
  
     // clamp to server defined max speed
     CL_ClampSpeed(cl.localmove);
  
     CL_ClampPitch();
  
     cl.cmd.angles[0] = ANGLE2SHORT(cl.viewangles[0]);
     cl.cmd.angles[1] = ANGLE2SHORT(cl.viewangles[1]);
     cl.cmd.angles[2] = ANGLE2SHORT(cl.viewangles[2]);
 }

Referenced by CL_Frame().

◆ IN_Activate()

void IN_Activate ( void )

Definition at line 117 of file input.c.

 {
     if (input.api.Grab) {
         input.api.Grab(IN_GetCurrentGrab());
     }
 }

Referenced by check_paused(), CL_Activate(), CL_CheckForPause(), CL_DeltaFrame(), in_changed_soft(), IN_Init(), Key_Event(), Key_SetDest(), and SCR_ModeChanged().

◆ IN_AttackDown()

static void IN_AttackDown ( void )

static

Definition at line 410 of file input.c.

 {
     KeyDown(&in_attack);
  
     if (cl_instantpacket->integer && cls.state == ca_active && cls.netchan) {
         cl.sendPacketNow = qtrue;
     }
 }

Referenced by CL_RegisterInput().

◆ IN_AttackUp()

static void IN_AttackUp ( void )

static

Definition at line 419 of file input.c.

 {
     KeyUp(&in_attack);
 }

Referenced by CL_RegisterInput().

◆ IN_BackDown()

static void IN_BackDown ( void )

static

Definition at line 395 of file input.c.

395 { KeyDown(&in_back); }

Referenced by CL_RegisterInput().

◆ IN_BackUp()

static void IN_BackUp ( void )

static

Definition at line 396 of file input.c.

396 { KeyUp(&in_back); }

Referenced by CL_RegisterInput().

◆ IN_CenterView()

static void IN_CenterView ( void )

static

Definition at line 443 of file input.c.

 {
     cl.viewangles[PITCH] = -SHORT2ANGLE(cl.frame.ps.pmove.delta_angles[PITCH]);
 }

Referenced by CL_RegisterInput(), and IN_MLookUp().

◆ in_changed_hard()

static void in_changed_hard ( cvar_t * self )

static

Definition at line 195 of file input.c.

 {
     input.modified = qtrue;
 }

Referenced by IN_Init().

◆ in_changed_soft()

static void in_changed_soft ( cvar_t * self )

static

Definition at line 200 of file input.c.

 {
     IN_Activate();
 }

Referenced by IN_Init().

◆ IN_DownDown()

static void IN_DownDown ( void )

static

Definition at line 387 of file input.c.

387 { KeyDown(&in_down); }

Referenced by CL_RegisterInput().

◆ IN_DownUp()

static void IN_DownUp ( void )

static

Definition at line 388 of file input.c.

388 { KeyUp(&in_down); }

Referenced by CL_RegisterInput().

◆ IN_ForwardDown()

static void IN_ForwardDown ( void )

static

Definition at line 393 of file input.c.

393 { KeyDown(&in_forward); }

Referenced by CL_RegisterInput().

◆ IN_ForwardUp()

static void IN_ForwardUp ( void )

static

Definition at line 394 of file input.c.

394 { KeyUp(&in_forward); }

Referenced by CL_RegisterInput().

◆ IN_Frame()

void IN_Frame ( void )

Definition at line 140 of file input.c.

 {
     if (input.modified) {
         IN_Restart_f();
         return;
     }
  
     if (input.api.GetEvents) {
         input.api.GetEvents();
     }
  
 #if USE_LIRC
     Lirc_GetEvents();
 #endif
 }

Referenced by CL_ProcessEvents().

◆ IN_GetAPI()

const inputAPI_t* IN_GetAPI ( )

Definition at line 79 of file input.c.

 {
     return &input.api;
 }

Referenced by vkpt_freecam_mousemove().

◆ IN_GetCurrentGrab()

static qboolean IN_GetCurrentGrab ( void )

static

Definition at line 84 of file input.c.

 {
     if (cls.active != ACT_ACTIVATED)
         return qfalse;  // main window doesn't have focus
  
     if (r_config.flags & QVF_FULLSCREEN)
         return qtrue;   // full screen
  
     if (cls.key_dest & (KEY_MENU | KEY_CONSOLE))
         return qfalse;  // menu or console is up
  
     if (cls.state != ca_active && cls.state != ca_cinematic)
         return qfalse;  // not connected
  
     if (in_grab->integer >= 2) {
         if (cls.demo.playback && !Key_IsDown(K_SHIFT))
             return qfalse;  // playing a demo (and not using freelook)
  
         if (cl.frame.ps.pmove.pm_type == PM_FREEZE)
             return qfalse;  // spectator mode
     }
  
     if (in_grab->integer >= 1)
         return qtrue;   // regular playing mode
  
     return qfalse;
 }

Referenced by IN_Activate().

◆ IN_Impulse()

static void IN_Impulse ( void )

static

Definition at line 438 of file input.c.

 {
     in_impulse = atoi(Cmd_Argv(1));
 }

Referenced by CL_RegisterInput().

◆ IN_Init()

void IN_Init ( void )

Definition at line 210 of file input.c.

 {
     qboolean ret = qfalse;
  
 #if USE_LIRC
     Lirc_Init();
 #endif
  
     in_enable = Cvar_Get("in_enable", "1", 0);
     in_enable->changed = in_changed_hard;
     if (!in_enable->integer) {
         Com_Printf("Mouse input disabled.\n");
         return;
     }
  
 #if USE_DINPUT
     in_direct = Cvar_Get("in_direct", "1", 0);
     if (in_direct->integer) {
         DI_FillAPI(&input.api);
         ret = input.api.Init();
         if (!ret) {
             Cvar_Set("in_direct", "0");
         }
     }
 #endif
  
     if (!ret) {
         VID_FillInputAPI(&input.api);
         ret = input.api.Init();
         if (!ret) {
             Cvar_Set("in_enable", "0");
             return;
         }
     }
  
 #if USE_DINPUT
     in_direct->changed = in_changed_hard;
 #endif
  
     in_grab = Cvar_Get("in_grab", "1", 0);
     in_grab->changed = in_changed_soft;
  
     IN_Activate();
 }

Referenced by CL_Init(), CL_RestartRefresh(), and IN_Restart_f().

◆ IN_KLookDown()

static void IN_KLookDown ( void )

static

Definition at line 383 of file input.c.

383 { KeyDown(&in_klook); }

Referenced by CL_RegisterInput().

◆ IN_KLookUp()

static void IN_KLookUp ( void )

static

Definition at line 384 of file input.c.

384 { KeyUp(&in_klook); }

Referenced by CL_RegisterInput().

◆ IN_LeftDown()

static void IN_LeftDown ( void )

static

Definition at line 389 of file input.c.

389 { KeyDown(&in_left); }

Referenced by CL_RegisterInput().

◆ IN_LeftUp()

static void IN_LeftUp ( void )

static

Definition at line 390 of file input.c.

390 { KeyUp(&in_left); }

Referenced by CL_RegisterInput().

◆ IN_LookdownDown()

static void IN_LookdownDown ( void )

static

Definition at line 399 of file input.c.

399 { KeyDown(&in_lookdown); }

Referenced by CL_RegisterInput().

◆ IN_LookdownUp()

static void IN_LookdownUp ( void )

static

Definition at line 400 of file input.c.

400 { KeyUp(&in_lookdown); }

Referenced by CL_RegisterInput().

◆ IN_LookupDown()

static void IN_LookupDown ( void )

static

Definition at line 397 of file input.c.

397 { KeyDown(&in_lookup); }

Referenced by CL_RegisterInput().

◆ IN_LookupUp()

static void IN_LookupUp ( void )

static

Definition at line 398 of file input.c.

398 { KeyUp(&in_lookup); }

Referenced by CL_RegisterInput().

◆ IN_MLookDown()

static void IN_MLookDown ( void )

static

Definition at line 448 of file input.c.

 {
     in_mlooking = qtrue;
 }

Referenced by CL_RegisterInput().

◆ IN_MLookUp()

static void IN_MLookUp ( void )

static

Definition at line 453 of file input.c.

 {
     in_mlooking = qfalse;
  
     if (!freelook->integer && lookspring->integer)
         IN_CenterView();
 }

Referenced by CL_RegisterInput().

◆ IN_MoveleftDown()

static void IN_MoveleftDown ( void )

static

Definition at line 401 of file input.c.

401 { KeyDown(&in_moveleft); }

Referenced by CL_RegisterInput().

◆ IN_MoveleftUp()

static void IN_MoveleftUp ( void )

static

Definition at line 402 of file input.c.

402 { KeyUp(&in_moveleft); }

Referenced by CL_RegisterInput().

◆ IN_MoverightDown()

static void IN_MoverightDown ( void )

static

Definition at line 403 of file input.c.

403 { KeyDown(&in_moveright); }

Referenced by CL_RegisterInput().

◆ IN_MoverightUp()

static void IN_MoverightUp ( void )

static

Definition at line 404 of file input.c.

404 { KeyUp(&in_moveright); }

Referenced by CL_RegisterInput().

◆ IN_Restart_f()

static void IN_Restart_f ( void )

static

Definition at line 129 of file input.c.

 {
     IN_Shutdown();
     IN_Init();
 }

Referenced by CL_RegisterInput(), and IN_Frame().

◆ IN_RightDown()

static void IN_RightDown ( void )

static

Definition at line 391 of file input.c.

391 { KeyDown(&in_right); }

Referenced by CL_RegisterInput().

◆ IN_RightUp()

static void IN_RightUp ( void )

static

Definition at line 392 of file input.c.

392 { KeyUp(&in_right); }

Referenced by CL_RegisterInput().

◆ IN_Shutdown()

void IN_Shutdown ( void )

Definition at line 173 of file input.c.

 {
 #if USE_DINPUT
     if (in_direct) {
         in_direct->changed = NULL;
     }
 #endif
     if (in_grab) {
         in_grab->changed = NULL;
     }
  
     if (input.api.Shutdown) {
         input.api.Shutdown();
     }
  
 #if USE_LIRC
     Lirc_Shutdown();
 #endif
  
     memset(&input, 0, sizeof(input));
 }

Referenced by CL_RestartRefresh(), CL_Shutdown(), and IN_Restart_f().

◆ IN_SpeedDown()

static void IN_SpeedDown ( void )

static

Definition at line 405 of file input.c.

405 { KeyDown(&in_speed); }

Referenced by CL_RegisterInput().

◆ IN_SpeedUp()

static void IN_SpeedUp ( void )

static

Definition at line 406 of file input.c.

406 { KeyUp(&in_speed); }

Referenced by CL_RegisterInput().

◆ IN_StrafeDown()

static void IN_StrafeDown ( void )

static

Definition at line 407 of file input.c.

407 { KeyDown(&in_strafe); }

Referenced by CL_RegisterInput().

◆ IN_StrafeUp()

static void IN_StrafeUp ( void )

static

Definition at line 408 of file input.c.

408 { KeyUp(&in_strafe); }

Referenced by CL_RegisterInput().

◆ IN_UpDown()

static void IN_UpDown ( void )

static

Definition at line 385 of file input.c.

385 { KeyDown(&in_up); }

Referenced by CL_RegisterInput().

◆ IN_UpUp()

static void IN_UpUp ( void )

static

Definition at line 386 of file input.c.

386 { KeyUp(&in_up); }

Referenced by CL_RegisterInput().

◆ IN_UseDown()

static void IN_UseDown ( void )

static

Definition at line 424 of file input.c.

 {
     KeyDown(&in_use);
  
     if (cl_instantpacket->integer && cls.state == ca_active && cls.netchan) {
         cl.sendPacketNow = qtrue;
     }
 }

Referenced by CL_RegisterInput().

◆ IN_UseUp()

static void IN_UseUp ( void )

static

Definition at line 433 of file input.c.

 {
     KeyUp(&in_use);
 }

Referenced by CL_RegisterInput().

◆ IN_WarpMouse()

void IN_WarpMouse	(	int	x,
		int	y
	)

Definition at line 161 of file input.c.

 {
     if (input.api.Warp) {
         input.api.Warp(x, y);
     }
 }

Referenced by UI_PushMenu().

◆ KeyClear()

static void KeyClear ( kbutton_t * b )

static

Definition at line 374 of file input.c.

 {
     b->msec = 0;
     b->state &= ~2;        // clear impulses
     if (b->state & 1) {
         b->downtime = com_eventTime; // still down
     }
 }

Referenced by CL_FinalizeCmd().

◆ KeyDown()

static void KeyDown ( kbutton_t * b )

static

Definition at line 298 of file input.c.

 {
     int k;
     char *c;
  
     c = Cmd_Argv(1);
     if (c[0])
         k = atoi(c);
     else
         k = -1;        // typed manually at the console for continuous down
  
     if (k == b->down[0] || k == b->down[1])
         return;        // repeating key
  
     if (!b->down[0])
         b->down[0] = k;
     else if (!b->down[1])
         b->down[1] = k;
     else {
         Com_WPrintf("Three keys down for a button!\n");
         return;
     }
  
     if (b->state & 1)
         return;        // still down
  
     // save timestamp
     c = Cmd_Argv(2);
     b->downtime = atoi(c);
     if (!b->downtime) {
         b->downtime = com_eventTime - 100;
     }
  
     b->state |= 1 + 2;    // down + impulse down
 }

Referenced by IN_AttackDown(), IN_BackDown(), IN_DownDown(), IN_ForwardDown(), IN_KLookDown(), IN_LeftDown(), IN_LookdownDown(), IN_LookupDown(), IN_MoveleftDown(), IN_MoverightDown(), IN_RightDown(), IN_SpeedDown(), IN_StrafeDown(), IN_UpDown(), and IN_UseDown().

◆ KeyUp()

static void KeyUp ( kbutton_t * b )

static

Definition at line 334 of file input.c.

 {
     int k;
     char *c;
     unsigned uptime;
  
     c = Cmd_Argv(1);
     if (c[0])
         k = atoi(c);
     else {
         // typed manually at the console, assume for unsticking, so clear all
         b->down[0] = b->down[1] = 0;
         b->state = 0;    // impulse up
         return;
     }
  
     if (b->down[0] == k)
         b->down[0] = 0;
     else if (b->down[1] == k)
         b->down[1] = 0;
     else
         return;        // key up without coresponding down (menu pass through)
     if (b->down[0] || b->down[1])
         return;        // some other key is still holding it down
  
     if (!(b->state & 1))
         return;        // still up (this should not happen)
  
     // save timestamp
     c = Cmd_Argv(2);
     uptime = atoi(c);
     if (!uptime) {
         b->msec += 10;
     } else if (uptime > b->downtime) {
         b->msec += uptime - b->downtime;
     }
  
     b->state &= ~1;        // now up
 }

Referenced by IN_AttackUp(), IN_BackUp(), IN_DownUp(), IN_ForwardUp(), IN_KLookUp(), IN_LeftUp(), IN_LookdownUp(), IN_LookupUp(), IN_MoveleftUp(), IN_MoverightUp(), IN_RightUp(), IN_SpeedUp(), IN_StrafeUp(), IN_UpUp(), and IN_UseUp().

◆ m_autosens_changed()

static void m_autosens_changed ( cvar_t * self )

static

Definition at line 689 of file input.c.

 {
     float fov;
  
     if (self->value > 90.0f && self->value <= 179.0f)
         fov = self->value;
     else
         fov = 90.0f;
  
     autosens_x = 1.0f / fov;
     autosens_y = 1.0f / V_CalcFov(fov, 4, 3);
 }

Referenced by CL_RegisterInput().

◆ ready_to_send()

static qboolean ready_to_send ( void )

inlinestatic

Definition at line 877 of file input.c.

 {
     unsigned msec;
  
     if (cl.sendPacketNow) {
         return qtrue;
     }
     if (cls.netchan->message.cursize || cls.netchan->reliable_ack_pending) {
         return qtrue;
     }
     if (!cl_maxpackets->integer) {
         return qtrue;
     }
  
     if (cl_maxpackets->integer < 10) {
         Cvar_Set("cl_maxpackets", "10");
     }
  
     msec = 1000 / cl_maxpackets->integer;
     if (msec) {
         msec = 100 / (100 / msec);
     }
     if (cls.realtime - cl.lastTransmitTime < msec) {
         return qfalse;
     }
  
     return qtrue;
 }

Referenced by CL_SendBatchedCmd(), and ready_to_send_hacked().

◆ ready_to_send_hacked()

static qboolean ready_to_send_hacked ( void )

inlinestatic

Definition at line 906 of file input.c.

 {
     if (!cl_fuzzhack->integer) {
         return qtrue; // packet drop hack disabled
     }
  
     if (cl.cmdNumber - cl.lastTransmitCmdNumberReal > 2) {
         return qtrue; // can't drop more than 2 cmds
     }
  
     return ready_to_send();
 }