#include "matrixlib.h"
#include "snd_main.h"
#include "view.h"
#include "cap.h"
#include "cl_parse.h"
#include "cl_particles.h"
#include "r_stats.h"
#include "cl_screen.h"

Include dependency graph for client.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	beam_t

struct	cl_clientmovement_state_t

struct	cl_downloadack_t

struct	cl_effect_t

struct	cl_locnode_t

struct	cl_soundstats_t

struct	client_state_t

struct	client_static_t

struct	cshift_t

struct	csqc_vidvars_t

struct	decalsystem_t

struct	dlight_t

struct	entity_persistent_t

struct	entity_render_t

struct	entity_t

struct	frameblend_t

struct	kbutton_t

struct	lightstyle_t

struct	rtlight_particle_t

struct	rtlight_t

struct	scoreboard_t

struct	showlmp_t

struct	tridecal_t

Macros
#define	CL_MAX_DOWNLOADACKS 4

#define	CL_Mesh_Scene()

#define	CL_Mesh_UI()

#define	CSHIFT_BONUS 2

#define	CSHIFT_CONTENTS 0

#define	CSHIFT_DAMAGE 1

#define	CSHIFT_POWERUP 3

#define	CSHIFT_VCSHIFT 4

#define	LATESTFRAMENUMS 32

#define	LIGHTFLAG_NORMALMODE 1

#define	LIGHTFLAG_REALTIMEMODE 2

#define	MAX_FRAMEBLENDS (MAX_FRAMEGROUPBLENDS * 2)

#define	MAX_RCONS 16

#define	NAME_LENGTH 64

#define	NUM_CSHIFTS 5

#define	NUM_TS_ERRORS 32

#define	SIGNONS 4

Enumerations
enum	cactive_t { ca_uninitialized , ca_dedicated , ca_disconnected , ca_connected }

enum	cl_parsingtextmode_t { CL_PARSETEXTMODE_NONE , CL_PARSETEXTMODE_PING , CL_PARSETEXTMODE_STATUS , CL_PARSETEXTMODE_STATUS_PLAYERID , CL_PARSETEXTMODE_STATUS_PLAYERIP }

enum	meshname_t { MESH_SCENE , MESH_UI , NUM_MESHENTITIES }

enum	qw_downloadtype_t { dl_none , dl_single , dl_skin , dl_model , dl_sound }

enum	waterlevel_t { WATERLEVEL_NONE , WATERLEVEL_WETFEET , WATERLEVEL_SWIMMING , WATERLEVEL_SUBMERGED }

Functions
void	CL_AllocLightFlash (entity_render_t ent, matrix4x4_t matrix, float radius, float red, float green, float blue, float decay, float lifetime, char *cubemapname, int style, int shadowenable, vec_t corona, vec_t coronasizescale, vec_t ambientscale, vec_t diffusescale, vec_t specularscale, int flags)

void	CL_Beam_AddPolygons (const beam_t *b)

void	CL_Beam_CalculatePositions (const beam_t *b, vec3_t start, vec3_t end)

void	CL_ClearState (void)

void	CL_ClearTempEntities (void)

void	CL_ClientMovement_PlayerMove_Frame (cl_clientmovement_state_t *s)

void	CL_ClientMovement_Replay (void)

void	CL_CutDemo (unsigned char *buf, fs_offset_t filesize)

void	CL_Demo_Init (void)

void	CL_Disconnect (void)

void	CL_Disconnect_f (cmd_state_t *cmd)

void	CL_DisconnectEx (qbool kicked, const char *reason,...)

void	CL_Effect (vec3_t org, model_t *model, int startframe, int framecount, float framerate)

void	CL_EstablishConnection (const char *host, int firstarg)

void	CL_ExpandCSQCRenderEntities (int num)

void	CL_ExpandEntities (int num)

void	CL_FindNonSolidLocation (const vec3_t in, vec3_t out, vec_t radius)

void	CL_ForwardToServer (const char *s)
	adds the string as a clc_stringcmd to the client message.

void	CL_ForwardToServer_f (cmd_state_t *cmd)
	adds the current command line as a clc_stringcmd to the client message.

double	CL_Frame (double time)

void	CL_Init (void)

void	CL_InitCommands (void)

void	CL_InitInput (void)

void	CL_Input (void)

float	CL_KeyState (kbutton_t *key)

void	CL_LerpUpdate (entity_t *e)

void	CL_Locs_FindLocationName (char *buffer, size_t buffersize, vec3_t point)

cl_locnode_t *	CL_Locs_FindNearest (const vec3_t point)

void	CL_Locs_Reload_f (cmd_state_t *cmd)

void	CL_MeshEntities_Init (void)

void	CL_MeshEntities_Scene_AddRenderEntity (void)

void	CL_MeshEntities_Scene_Clear (void)

void	CL_MeshEntities_Scene_FinalizeRenderEntity (void)

void	CL_MoveLerpEntityStates (entity_t *ent)

void	CL_NewBeam (int ent, vec3_t start, vec3_t end, model_t *m, int lightning)

void	CL_NewFrameReceived (int num)

entity_render_t *	CL_NewTempEntity (double shadertime)

void	CL_NextDemo (void)

void	CL_ParseEntityLump (char *entitystring)

void	CL_ParseTEnt (void)

void	CL_PasteDemo (unsigned char *buf, fs_offset_t filesize)

void	CL_PlayDemo (const char *demo)

void	CL_PlayDemo_f (cmd_state_t *cmd)

void	CL_ReadDemoMessage (void)

void	CL_Record_f (cmd_state_t *cmd)

void	CL_RelinkBeams (void)

void	CL_RelinkLightFlashes (void)

void	CL_RotateMoves (const matrix4x4_t *m)

void	CL_SendMove (void)

void	CL_SetEntityColormapColors (entity_render_t *ent, int colormap)

void	CL_SetInfo (const char key, const char value, qbool send, qbool allowstarkey, qbool allowmodel, qbool quiet)

void	CL_Shutdown (void)

void	CL_StartVideo (void)

void	CL_Stop_f (cmd_state_t *cmd)

void	CL_StopPlayback (void)

void	CL_TimeDemo_f (cmd_state_t *cmd)

void	CL_UpdateEntityShading (void)

void	CL_UpdateMoveVars (void)

void	CL_UpdateRenderEntity (entity_render_t *ent)

void	CL_UpdateViewEntities (void)

void	CL_UpdateWorld (void)

void	CL_ValidateState (entity_state_t *s)

void	CL_WriteDemoMessage (sizebuf_t *mesage)

void	CL_WriteToServer (void)

Variables
client_state_t	cl

cvar_t	cl_anglespeedkey

cvar_t	cl_areagrid_link_SOLID_NOT

cvar_t	cl_autodemo

cvar_t	cl_autodemo_delete

cvar_t	cl_autodemo_nameformat

cvar_t	cl_autofire

cvar_t	cl_backspeed

cvar_t	cl_color

cvar_t	cl_explosions_alpha_end

cvar_t	cl_explosions_alpha_start

cvar_t	cl_explosions_lifetime

cvar_t	cl_explosions_size_end

cvar_t	cl_explosions_size_start

cvar_t	cl_forwardspeed

int	cl_ignoremousemoves

cvar_t	cl_locs_enable

entity_t	cl_meshentities [NUM_MESHENTITIES]

model_t	cl_meshentitymodels [NUM_MESHENTITIES]

const char *	cl_meshentitynames [NUM_MESHENTITIES]

cvar_t	cl_movespeedkey

cvar_t	cl_name
	User-visible names of these CF_USERINFO cvars must be matched in CL_SetInfo()!

cvar_t	cl_nettimesyncboundmode

cvar_t	cl_nettimesyncboundtolerance

cvar_t	cl_nettimesyncfactor

cvar_t	cl_pitchdriftspeed

cvar_t	cl_pitchspeed

cvar_t	cl_playermodel

cvar_t	cl_playerskin

cvar_t	cl_pmodel

cvar_t	cl_prydoncursor

cvar_t	cl_prydoncursor_notrace

cvar_t	cl_rate

cvar_t	cl_rate_burstsize

cvar_t	cl_shownet

cvar_t	cl_sidespeed

cvar_t	cl_stainmaps

cvar_t	cl_stainmaps_clearonload

cvar_t	cl_startdemos

cvar_t	cl_upspeed

cvar_t	cl_yawspeed

client_static_t	cls

cvar_t	freelook

kbutton_t	in_klook

kbutton_t	in_mlook

kbutton_t	in_speed

kbutton_t	in_strafe

cvar_t	lookspring

cvar_t	lookstrafe

cvar_t	m_forward

cvar_t	m_pitch

cvar_t	m_side

cvar_t	m_yaw

cvar_t	r_draweffects

cvar_t	rcon_address

cvar_t	rcon_password

qbool	sb_showscores

cvar_t	sensitivity

Macro Definition Documentation

◆ CL_MAX_DOWNLOADACKS

#define CL_MAX_DOWNLOADACKS 4

Definition at line 546 of file client.h.

Referenced by CL_ParseDownload(), and CL_SendMove().

◆ CL_Mesh_Scene

#define CL_Mesh_Scene ( )

Value:

(&cl_meshentitymodels[MESH_SCENE])

cl_meshentitymodels

model_t cl_meshentitymodels[NUM_MESHENTITIES]

Definition cl_main.c:2514

MESH_SCENE

@ MESH_SCENE

Definition client.h:1364

Definition at line 1371 of file client.h.

Referenced by CL_Beam_AddPolygons(), CL_MeshEntities_Scene_Clear(), and VM_CL_R_PolygonBegin().

◆ CL_Mesh_UI

#define CL_Mesh_UI ( )

Value:

(&cl_meshentitymodels[MESH_UI])

MESH_UI

@ MESH_UI

Definition client.h:1365

Definition at line 1372 of file client.h.

Referenced by DrawQ_FlushUI(), DrawQ_Line(), DrawQ_Pic(), DrawQ_RotPic(), DrawQ_String_Scale(), DrawQ_SuperPic(), R_DebugLine(), and VM_CL_R_PolygonBegin().

◆ CSHIFT_BONUS

#define CSHIFT_BONUS 2

Definition at line 513 of file client.h.

Referenced by V_BonusFlash_f(), and V_FadeViewFlashs().

◆ CSHIFT_CONTENTS

#define CSHIFT_CONTENTS 0

Definition at line 511 of file client.h.

Referenced by V_CalcViewBlend().

◆ CSHIFT_DAMAGE

#define CSHIFT_DAMAGE 1

Definition at line 512 of file client.h.

Referenced by R_MotionBlurView(), V_FadeViewFlashs(), and V_ParseDamage().

◆ CSHIFT_POWERUP

#define CSHIFT_POWERUP 3

Definition at line 514 of file client.h.

Referenced by V_CalcViewBlend().

◆ CSHIFT_VCSHIFT

#define CSHIFT_VCSHIFT 4

Definition at line 515 of file client.h.

Referenced by V_CalcViewBlend().

◆ LATESTFRAMENUMS

#define LATESTFRAMENUMS 32

Definition at line 959 of file client.h.

Referenced by CL_NewFrameReceived(), and CL_SendMove().

◆ LIGHTFLAG_NORMALMODE

#define LIGHTFLAG_NORMALMODE 1

Definition at line 34 of file client.h.

Referenced by CL_LinkNetworkEntity(), CL_NewParticlesFromEffectinfo(), CL_ParseTempEntity(), CL_ParticleEffect_Fallback(), CL_RelinkBeams(), R_CompleteLightPoint(), R_Shadow_BounceGrid_AssignPhotons_Task(), R_Shadow_DrawCoronas(), R_Shadow_EditLights_DrawSelectedLightProperties(), R_Shadow_EditLights_Edit_f(), R_Shadow_PrepareLights(), R_Shadow_UpdateBounceGridTexture(), VM_CL_R_AddDynamicLight(), VM_CL_te_customflash(), VM_CL_te_explosion2(), and VM_CL_te_explosionrgb().

◆ LIGHTFLAG_REALTIMEMODE

◆ MAX_FRAMEBLENDS

#define MAX_FRAMEBLENDS (MAX_FRAMEGROUPBLENDS * 2)

Definition at line 309 of file client.h.

Referenced by Mod_Alias_CalculateBoundingBox(), Mod_Alias_GetExtendedTagInfoForIndex(), Mod_Alias_GetTagMatrix(), Mod_Alias_MorphMesh_CompileFrames(), Mod_MD3_AnimateVertices(), Mod_MDL_AnimateVertices(), Mod_Skeletal_BuildTransforms(), R_Model_Sprite_Draw_TransparentCallback(), VM_CL_skel_build(), VM_FrameBlendFromFrameGroupBlend(), and VM_SV_skel_build().

◆ MAX_RCONS

#define MAX_RCONS 16

Definition at line 619 of file client.h.

Referenced by CL_Rcon_f(), NetConn_ClientParsePacket(), and NetConn_UpdateSockets().

◆ NAME_LENGTH

#define NAME_LENGTH 64

Definition at line 518 of file client.h.

◆ NUM_CSHIFTS

#define NUM_CSHIFTS 5

Definition at line 516 of file client.h.

Referenced by V_CalcViewBlend().

◆ NUM_TS_ERRORS

#define NUM_TS_ERRORS 32

Definition at line 874 of file client.h.

Referenced by CL_NetworkTimeReceived().

◆ SIGNONS

#define SIGNONS 4

Definition at line 525 of file client.h.

Referenced by CL_ClientMovement_Replay(), CL_KeepaliveMessage(), CL_NetworkTimeReceived(), CL_ParseServerMessage(), CL_ReadDemoMessage(), CL_SendMove(), CL_SetSignonStage_WithMsg(), CL_UpdateScreen(), CL_UpdateWorld(), QW_CL_RequestNextDownload(), SCR_DrawCurlDownload(), SCR_DrawInfobarString(), SCR_DrawQWDownload(), SCR_DrawScreen(), SCR_SetUpToDrawConsole(), V_CalcRefdef(), and V_CalcViewBlend().

Enumeration Type Documentation

◆ cactive_t

enum cactive_t

Enumerator
ca_uninitialized
ca_dedicated
ca_disconnected
ca_connected

Definition at line 527 of file client.h.

{
    ca_uninitialized,   // during early startup
    ca_dedicated,       // a dedicated server with no ability to start a client
    ca_disconnected,    // full screen console with no connection
    ca_connected        // valid netcon, talking to a server
}

◆ cl_parsingtextmode_t

enum cl_parsingtextmode_t

Enumerator
CL_PARSETEXTMODE_NONE
CL_PARSETEXTMODE_PING
CL_PARSETEXTMODE_STATUS
CL_PARSETEXTMODE_STATUS_PLAYERID
CL_PARSETEXTMODE_STATUS_PLAYERIP

Definition at line 711 of file client.h.

{
    CL_PARSETEXTMODE_NONE,
    CL_PARSETEXTMODE_PING,
    CL_PARSETEXTMODE_STATUS,
    CL_PARSETEXTMODE_STATUS_PLAYERID,
    CL_PARSETEXTMODE_STATUS_PLAYERIP
}

◆ meshname_t

enum meshname_t

Enumerator
MESH_SCENE
MESH_UI
NUM_MESHENTITIES

Definition at line 1363 of file client.h.

                        {
    MESH_SCENE, // CSQC R_PolygonBegin, potentially also engine particles and debug stuff
    MESH_UI,
    NUM_MESHENTITIES,
} meshname_t;

◆ qw_downloadtype_t

enum qw_downloadtype_t

Enumerator
dl_none
dl_single
dl_skin
dl_model
dl_sound

Definition at line 536 of file client.h.

{
    dl_none,
    dl_single,
    dl_skin,
    dl_model,
    dl_sound
}

◆ waterlevel_t

enum waterlevel_t

Enumerator
WATERLEVEL_NONE
WATERLEVEL_WETFEET
WATERLEVEL_SWIMMING
WATERLEVEL_SUBMERGED

Definition at line 1323 of file client.h.

{
    WATERLEVEL_NONE,
    WATERLEVEL_WETFEET,
    WATERLEVEL_SWIMMING,
    WATERLEVEL_SUBMERGED
}

Function Documentation

◆ CL_AllocLightFlash()

void CL_AllocLightFlash	(	entity_render_t *	ent,
		matrix4x4_t *	matrix,
		float	radius,
		float	red,
		float	green,
		float	blue,
		float	decay,
		float	lifetime,
		char *	cubemapname,
		int	style,
		int	shadowenable,
		vec_t	corona,
		vec_t	coronasizescale,
		vec_t	ambientscale,
		vec_t	diffusescale,
		vec_t	specularscale,
		int	flags )

extern

Definition at line 852 of file cl_main.c.

{
    int i;
    dlight_t *dl;
 
// then look for anything else
    dl = cl.dlights;
    for (i = 0;i < cl.max_dlights;i++, dl++)
        if (!dl->radius)
            break;
 
    // unable to find one
    if (i == cl.max_dlights)
        return;
 
    //Con_Printf("dlight %i : %f %f %f : %f %f %f\n", i, org[0], org[1], org[2], red * radius, green * radius, blue * radius);
    memset (dl, 0, sizeof(*dl));
    cl.num_dlights = max(cl.num_dlights, i + 1);
    Matrix4x4_Normalize(&dl->matrix, matrix);
    dl->ent = ent;
    Matrix4x4_OriginFromMatrix(&dl->matrix, dl->origin);
    CL_FindNonSolidLocation(dl->origin, dl->origin, 6);
    Matrix4x4_SetOrigin(&dl->matrix, dl->origin[0], dl->origin[1], dl->origin[2]);
    dl->radius = radius;
    dl->color[0] = red;
    dl->color[1] = green;
    dl->color[2] = blue;
    dl->initialradius = radius;
    dl->initialcolor[0] = red;
    dl->initialcolor[1] = green;
    dl->initialcolor[2] = blue;
    dl->decay = decay / radius; // changed decay to be a percentage decrease
    dl->intensity = 1; // this is what gets decayed
    if (lifetime)
        dl->die = cl.time + lifetime;
    else
        dl->die = 0;
    dl->cubemapname[0] = 0;
    if (cubemapname && cubemapname[0])
        dp_strlcpy(dl->cubemapname, cubemapname, sizeof(dl->cubemapname));
    dl->style = style;
    dl->shadow = shadowenable;
    dl->corona = corona;
    dl->flags = flags;
    dl->coronasizescale = coronasizescale;
    dl->ambientscale = ambientscale;
    dl->diffusescale = diffusescale;
    dl->specularscale = specularscale;
}

References dlight_t::ambientscale, blue, cl, CL_FindNonSolidLocation(), dlight_t::color, dlight_t::corona, dlight_t::coronasizescale, dlight_t::cubemapname, dlight_t::decay, dlight_t::die, dlight_t::diffusescale, client_state_t::dlights, dp_strlcpy, dlight_t::ent, dlight_t::flags, flags, green, i, dlight_t::initialcolor, dlight_t::initialradius, dlight_t::intensity, dlight_t::matrix, Matrix4x4_Normalize(), Matrix4x4_OriginFromMatrix(), Matrix4x4_SetOrigin(), max, client_state_t::max_dlights, client_state_t::num_dlights, dlight_t::origin, dlight_t::radius, dlight_t::shadow, dlight_t::specularscale, dlight_t::style, style, and client_state_t::time.

Referenced by CL_NewParticlesFromEffectinfo(), CL_ParseTempEntity(), CL_ParticleEffect_Fallback(), VM_CL_te_customflash(), VM_CL_te_explosion2(), and VM_CL_te_explosionrgb().

◆ CL_Beam_AddPolygons()

void CL_Beam_AddPolygons ( const beam_t * b )

Definition at line 129 of file r_lightning.c.

{
    vec3_t beamdir, right, up, offset, start, end;
    vec_t beamscroll = r_refdef.scene.time * -r_lightningbeam_scroll.value;
    vec_t beamrepeatscale = 1.0f / r_lightningbeam_repeatdistance.value;
    float length, t1, t2;
    model_t *mod;
    msurface_t *surf;
 
    if (r_lightningbeam_qmbtexture.integer && cl_beams_externaltexture.currentskinframe == NULL)
        CL_Beams_SetupExternalTexture();
    if (!r_lightningbeam_qmbtexture.integer && cl_beams_builtintexture.currentskinframe == NULL)
        CL_Beams_SetupBuiltinTexture();
 
    // calculate beam direction (beamdir) vector and beam length
    // get difference vector
    CL_Beam_CalculatePositions(b, start, end);
    VectorSubtract(end, start, beamdir);
    // find length of difference vector
    length = sqrt(DotProduct(beamdir, beamdir));
    // calculate scale to make beamdir a unit vector (normalized)
    t1 = 1.0f / length;
    // scale beamdir so it is now normalized
    VectorScale(beamdir, t1, beamdir);
 
    // calculate up vector such that it points toward viewer, and rotates around the beamdir
    // get direction from start of beam to viewer
    VectorSubtract(r_refdef.view.origin, start, up);
    // remove the portion of the vector that moves along the beam
    // (this leaves only a vector pointing directly away from the beam)
    t1 = -DotProduct(up, beamdir);
    VectorMA(up, t1, beamdir, up);
    // generate right vector from forward and up, the result is unnormalized
    CrossProduct(beamdir, up, right);
    // now normalize the right vector and up vector
    VectorNormalize(right);
    VectorNormalize(up);
 
    // calculate T coordinate scrolling (start and end texcoord along the beam)
    t1 = beamscroll;
    t1 = t1 - (int)t1;
    t2 = t1 + beamrepeatscale * length;
 
    // the beam is 3 polygons in this configuration:
    //  *   2
    //   * *
    // 1*****
    //   * *
    //  *   3
    // they are showing different portions of the beam texture, creating an
    // illusion of a beam that appears to curl around in 3D space
    // (and realize that the whole polygon assembly orients itself to face
    //  the viewer)
 
    mod = CL_Mesh_Scene();
    surf = Mod_Mesh_AddSurface(mod, r_lightningbeam_qmbtexture.integer ? &cl_beams_externaltexture : &cl_beams_builtintexture, false);
    // polygon 1
    VectorM(r_lightningbeam_thickness.value, right, offset);
    CL_Beam_AddQuad(mod, surf, start, end, offset, t1, t2);
    // polygon 2
    VectorMAM(r_lightningbeam_thickness.value * 0.70710681f, right, r_lightningbeam_thickness.value * 0.70710681f, up, offset);
    CL_Beam_AddQuad(mod, surf, start, end, offset, t1 + 0.33f, t2 + 0.33f);
    // polygon 3
    VectorMAM(r_lightningbeam_thickness.value * 0.70710681f, right, r_lightningbeam_thickness.value * -0.70710681f, up, offset);
    CL_Beam_AddQuad(mod, surf, start, end, offset, t1 + 0.66f, t2 + 0.66f);
}

References b, CL_Beam_AddQuad(), CL_Beam_CalculatePositions(), cl_beams_builtintexture, cl_beams_externaltexture, CL_Beams_SetupBuiltinTexture(), CL_Beams_SetupExternalTexture(), CL_Mesh_Scene, CrossProduct, texture_t::currentskinframe, DotProduct, int(), cvar_t::integer, length, mod(), Mod_Mesh_AddSurface(), NULL, offset, r_refdef_view_t::origin, r_lightningbeam_qmbtexture, r_lightningbeam_repeatdistance, r_lightningbeam_scroll, r_lightningbeam_thickness, r_refdef, right, r_refdef_t::scene, sqrt(), r_refdef_scene_t::time, up, cvar_t::value, VectorM, VectorMA, VectorMAM, VectorNormalize, VectorScale, VectorSubtract, and r_refdef_t::view.

Referenced by CL_RelinkBeams().

◆ CL_Beam_CalculatePositions()

void CL_Beam_CalculatePositions	(	const beam_t *	b,
		vec3_t	start,
		vec3_t	end )

Definition at line 1851 of file cl_main.c.

{
    VectorCopy(b->start, start);
    VectorCopy(b->end, end);
 
    // if coming from the player, update the start position
    if (b->entity == cl.viewentity)
    {
        if (cl_beams_quakepositionhack.integer && !chase_active.integer)
        {
            // LadyHavoc: this is a stupid hack from Quake that makes your
            // lightning appear to come from your waist and cover less of your
            // view
            // in Quake this hack was applied to all players (causing the
            // infamous crotch-lightning), but in darkplaces and QuakeWorld it
            // only applies to your own lightning, and only in first person
            Matrix4x4_OriginFromMatrix(&cl.entities[cl.viewentity].render.matrix, start);
        }
        if (cl_beams_instantaimhack.integer)
        {
            vec3_t dir, localend;
            vec_t len;
            // LadyHavoc: this updates the beam direction to match your
            // viewangles
            VectorSubtract(end, start, dir);
            len = VectorLength(dir);
            VectorNormalize(dir);
            VectorSet(localend, len, 0, 0);
            Matrix4x4_Transform(&r_refdef.view.matrix, localend, end);
        }
    }
}

References b, chase_active, cl, cl_beams_instantaimhack, cl_beams_quakepositionhack, dir, client_state_t::entities, cvar_t::integer, entity_render_t::matrix, r_refdef_view_t::matrix, Matrix4x4_OriginFromMatrix(), Matrix4x4_Transform(), r_refdef, entity_t::render, VectorCopy, VectorLength, VectorNormalize, VectorSet, VectorSubtract, r_refdef_t::view, and client_state_t::viewentity.

Referenced by CL_Beam_AddPolygons(), and CL_RelinkBeams().

◆ CL_ClearState()

void CL_ClearState ( void )

Definition at line 125 of file cl_main.c.

{
    int i;
    entity_t *ent;
 
    CL_VM_ShutDown();
 
// wipe the entire cl structure
    Mem_EmptyPool(cls.levelmempool);
    memset (&cl, 0, sizeof(cl));
 
    S_StopAllSounds();
 
    // reset the view zoom interpolation
    cl.mviewzoom[0] = cl.mviewzoom[1] = 1;
    cl.sensitivityscale = 1.0f;
 
    // enable rendering of the world and such
    cl.csqc_vidvars.drawworld = r_drawworld.integer != 0;
    cl.csqc_vidvars.drawenginesbar = true;
    cl.csqc_vidvars.drawcrosshair = true;
 
    // set up the float version of the stats array for easier access to float stats
    cl.statsf = (float *)cl.stats;
 
    cl.num_entities = 0;
    cl.num_static_entities = 0;
    cl.num_brushmodel_entities = 0;
 
    // tweak these if the game runs out
    cl.max_csqcrenderentities = 0;
    cl.max_entities = MAX_ENTITIES_INITIAL;
    cl.max_static_entities = MAX_STATICENTITIES;
    cl.max_effects = MAX_EFFECTS;
    cl.max_beams = MAX_BEAMS;
    cl.max_dlights = MAX_DLIGHTS;
    cl.max_lightstyle = MAX_LIGHTSTYLES;
    cl.max_brushmodel_entities = MAX_EDICTS;
    cl.max_particles = MAX_PARTICLES_INITIAL; // grows dynamically
    cl.max_showlmps = 0;
 
    cl.num_dlights = 0;
    cl.num_effects = 0;
    cl.num_beams = 0;
 
    cl.csqcrenderentities = NULL;
    cl.entities = (entity_t *)Mem_Alloc(cls.levelmempool, cl.max_entities * sizeof(entity_t));
    cl.entities_active = (unsigned char *)Mem_Alloc(cls.levelmempool, cl.max_brushmodel_entities * sizeof(unsigned char));
    cl.static_entities = (entity_t *)Mem_Alloc(cls.levelmempool, cl.max_static_entities * sizeof(entity_t));
    cl.effects = (cl_effect_t *)Mem_Alloc(cls.levelmempool, cl.max_effects * sizeof(cl_effect_t));
    cl.beams = (beam_t *)Mem_Alloc(cls.levelmempool, cl.max_beams * sizeof(beam_t));
    cl.dlights = (dlight_t *)Mem_Alloc(cls.levelmempool, cl.max_dlights * sizeof(dlight_t));
    cl.lightstyle = (lightstyle_t *)Mem_Alloc(cls.levelmempool, cl.max_lightstyle * sizeof(lightstyle_t));
    cl.brushmodel_entities = (int *)Mem_Alloc(cls.levelmempool, cl.max_brushmodel_entities * sizeof(int));
    cl.particles = (particle_t *) Mem_Alloc(cls.levelmempool, cl.max_particles * sizeof(particle_t));
    cl.showlmps = NULL;
 
    // LadyHavoc: have to set up the baseline info for alpha and other stuff
    for (i = 0;i < cl.max_entities;i++)
    {
        cl.entities[i].state_baseline = defaultstate;
        cl.entities[i].state_previous = defaultstate;
        cl.entities[i].state_current = defaultstate;
    }
 
    if (IS_NEXUIZ_DERIVED(gamemode))
    {
        VectorSet(cl.playerstandmins, -16, -16, -24);
        VectorSet(cl.playerstandmaxs, 16, 16, 45);
        VectorSet(cl.playercrouchmins, -16, -16, -24);
        VectorSet(cl.playercrouchmaxs, 16, 16, 25);
    }
    else
    {
        VectorSet(cl.playerstandmins, -16, -16, -24);
        VectorSet(cl.playerstandmaxs, 16, 16, 24);
        VectorSet(cl.playercrouchmins, -16, -16, -24);
        VectorSet(cl.playercrouchmaxs, 16, 16, 24);
    }
 
    // disable until we get textures for it
    R_ResetSkyBox();
 
    ent = &cl.entities[0];
    // entire entity array was cleared, so just fill in a few fields
    ent->state_current.active = true;
    ent->render.model = cl.worldmodel = NULL; // no world model yet
    ent->render.alpha = 1;
    ent->render.flags = RENDER_SHADOW | RENDER_LIGHT;
    Matrix4x4_CreateFromQuakeEntity(&ent->render.matrix, 0, 0, 0, 0, 0, 0, 1);
    ent->render.allowdecals = true;
    CL_UpdateRenderEntity(&ent->render);
 
    // noclip is turned off at start
    noclip_anglehack = false;
 
    // mark all frames invalid for delta
    memset(cl.qw_deltasequence, -1, sizeof(cl.qw_deltasequence));
 
    // set bestweapon data back to Quake data
    IN_BestWeapon_ResetData();
 
    CL_Screen_NewMap();
}

Referenced by CL_ParseServerInfo().

◆ CL_ClearTempEntities()

void CL_ClearTempEntities ( void )

Definition at line 781 of file cl_main.c.

{
    r_refdef.scene.numtempentities = 0;
    // grow tempentities buffer on request
    if (r_refdef.scene.expandtempentities)
    {
        Con_Printf("CL_NewTempEntity: grow maxtempentities from %i to %i\n", r_refdef.scene.maxtempentities, r_refdef.scene.maxtempentities * 2);
        r_refdef.scene.maxtempentities *= 2;
        r_refdef.scene.tempentities = (entity_render_t *)Mem_Realloc(cls.permanentmempool, r_refdef.scene.tempentities, sizeof(entity_render_t) * r_refdef.scene.maxtempentities);
        r_refdef.scene.expandtempentities = false;
    }
}

References cls, Con_Printf(), r_refdef_scene_t::expandtempentities, r_refdef_scene_t::maxtempentities, Mem_Realloc, r_refdef_scene_t::numtempentities, client_static_t::permanentmempool, r_refdef, r_refdef_t::scene, and r_refdef_scene_t::tempentities.

Referenced by CL_UpdateWorld().

◆ CL_ClientMovement_PlayerMove_Frame()

void CL_ClientMovement_PlayerMove_Frame ( cl_clientmovement_state_t * s )

Definition at line 1586 of file cl_input.c.

{
    // if a move is more than 50ms, do it as two moves (matching qwsv)
    //Con_Printf("%i ", s.cmd.msec);
    if(s->cmd.frametime > 0.0005)
    {
        if (s->cmd.frametime > 0.05)
        {
            s->cmd.frametime /= 2;
            CL_ClientMovement_PlayerMove(s);
        }
        CL_ClientMovement_PlayerMove(s);
    }
    else
    {
        // we REALLY need this handling to happen, even if the move is not executed
        if (!s->cmd.jump)
            s->cmd.canjump = true;
    }
}

References usercmd_t::canjump, CL_ClientMovement_PlayerMove(), cl_clientmovement_state_t::cmd, usercmd_t::frametime, and usercmd_t::jump.

Referenced by CL_ClientMovement_Replay(), and VM_CL_runplayerphysics().

◆ CL_ClientMovement_Replay()

void CL_ClientMovement_Replay ( void )

Definition at line 1607 of file cl_input.c.

{
    int i;
    double totalmovemsec;
    cl_clientmovement_state_t s;
 
    VectorCopy(cl.mvelocity[0], cl.movement_velocity);
 
    if (cl.movement_predicted && !cl.movement_replay)
        return;
 
    if (!cl_movement_replay.integer)
        return;
 
    // set up starting state for the series of moves
    memset(&s, 0, sizeof(s));
    VectorCopy(cl.entities[cl.playerentity].state_current.origin, s.origin);
    VectorCopy(cl.mvelocity[0], s.velocity);
    s.crouched = true; // will be updated on first move
    //Con_Printf("movement replay starting org %f %f %f vel %f %f %f\n", s.origin[0], s.origin[1], s.origin[2], s.velocity[0], s.velocity[1], s.velocity[2]);
 
    totalmovemsec = 0;
    for (i = 0;i < CL_MAX_USERCMDS;i++)
        if (cl.movecmd[i].sequence > cls.servermovesequence)
            totalmovemsec += cl.movecmd[i].msec;
    cl.movement_predicted = totalmovemsec >= cl_movement_minping.value && cls.servermovesequence && (cl_movement.integer && !cls.demoplayback && cls.signon == SIGNONS && cl.stats[STAT_HEALTH] > 0 && !cl.intermission);
    //Con_Printf("%i = %.0f >= %.0f && %u && (%i && %i && %i == %i && %i > 0 && %i\n", cl.movement_predicted, totalmovemsec, cl_movement_minping.value, cls.servermovesequence, cl_movement.integer, !cls.demoplayback, cls.signon, SIGNONS, cl.stats[STAT_HEALTH], !cl.intermission);
    if (cl.movement_predicted)
    {
        //Con_Printf("%ims\n", cl.movecmd[0].msec);
 
        // replay the input queue to predict current location
        // note: this relies on the fact there's always one queue item at the end
 
        // find how many are still valid
        for (i = 0;i < CL_MAX_USERCMDS;i++)
            if (cl.movecmd[i].sequence <= cls.servermovesequence)
                break;
        // now walk them in oldest to newest order
        for (i--;i >= 0;i--)
        {
            s.cmd = cl.movecmd[i];
            if (i < CL_MAX_USERCMDS - 1)
                s.cmd.canjump = cl.movecmd[i+1].canjump;
 
            CL_ClientMovement_PlayerMove_Frame(&s);
 
            cl.movecmd[i].canjump = s.cmd.canjump;
        }
        //Con_Printf("\n");
        CL_ClientMovement_UpdateStatus(&s);
    }
    else
    {
        // get the first movement queue entry to know whether to crouch and such
        s.cmd = cl.movecmd[0];
    }
 
    if (!cls.demoplayback) // for bob, speedometer
    {
        cl.movement_replay = false;
        // update the interpolation target position and velocity
        VectorCopy(s.origin, cl.movement_origin);
        VectorCopy(s.velocity, cl.movement_velocity);
    }
 
    // update the onground flag if appropriate
    if (cl.movement_predicted)
    {
        // when predicted we simply set the flag according to the UpdateStatus
        cl.onground = s.onground;
    }
    else
    {
        // when not predicted, cl.onground is cleared by cl_parse.c each time
        // an update packet is received, but can be forced on here to hide
        // server inconsistencies in the onground flag
        // (which mostly occur when stepping up stairs at very high framerates
        //  where after the step up the move continues forward and not
        //  downward so the ground is not detected)
        //
        // such onground inconsistencies can cause jittery gun bobbing and
        // stair smoothing, so we set onground if UpdateStatus says so
        if (s.onground)
            cl.onground = true;
    }
}

References usercmd_t::canjump, cl, CL_ClientMovement_PlayerMove_Frame(), CL_ClientMovement_UpdateStatus(), CL_MAX_USERCMDS, cl_movement, cl_movement_minping, cl_movement_replay, cls, cl_clientmovement_state_t::cmd, cl_clientmovement_state_t::crouched, client_static_t::demoplayback, client_state_t::entities, i, cvar_t::integer, client_state_t::intermission, client_state_t::movecmd, client_state_t::movement_origin, client_state_t::movement_predicted, client_state_t::movement_replay, client_state_t::movement_velocity, usercmd_t::msec, client_state_t::mvelocity, cl_clientmovement_state_t::onground, client_state_t::onground, cl_clientmovement_state_t::origin, entity_state_t::origin, client_state_t::playerentity, usercmd_t::sequence, client_static_t::servermovesequence, client_static_t::signon, SIGNONS, STAT_HEALTH, entity_t::state_current, client_state_t::stats, cvar_t::value, VectorCopy, and cl_clientmovement_state_t::velocity.

Referenced by CL_UpdateWorld().

◆ CL_CutDemo()

void CL_CutDemo	(	unsigned char **	buf,
		fs_offset_t *	filesize )

Definition at line 137 of file cl_demo.c.

{
    *buf = NULL;
    *filesize = 0;
 
    FS_Close(cls.demofile);
    *buf = FS_LoadFile(cls.demoname, tempmempool, false, filesize);
 
    // restart the demo recording
    cls.demofile = FS_OpenRealFile(cls.demoname, "wb", false);
    if(!cls.demofile)
        Sys_Error("failed to reopen the demo file");
    FS_Printf(cls.demofile, "%i\n", cls.forcetrack);
}

References buf, cls, client_static_t::demofile, client_static_t::demoname, client_static_t::forcetrack, FS_Close(), FS_LoadFile(), FS_OpenRealFile(), FS_Printf(), NULL, Sys_Error(), and tempmempool.

Referenced by CL_VM_Init().

◆ CL_Demo_Init()

void CL_Demo_Init ( void )

Definition at line 737 of file cl_demo.c.

{
    Cmd_AddCommand(CF_CLIENT, "record", CL_Record_f, "record a demo");
    Cmd_AddCommand(CF_CLIENT, "stop", CL_Stop_f, "stop recording or playing a demo");
    Cmd_AddCommand(CF_CLIENT, "playdemo", CL_PlayDemo_f, "watch a demo file");
    Cmd_AddCommand(CF_CLIENT, "timedemo", CL_TimeDemo_f, "play back a demo as fast as possible and save statistics to benchmark.log");
    Cmd_AddCommand(CF_CLIENT, "startdemos", CL_Startdemos_f, "start playing back the selected demos sequentially (used at end of startup script)");
    Cmd_AddCommand(CF_CLIENT, "demos", CL_Demos_f, "restart looping demos defined by the last startdemos command");
    Cmd_AddCommand(CF_CLIENT, "stopdemo", CL_Stopdemo_f, "stop playing or recording demo (like stop command) and return to looping demos");
    // LadyHavoc: added pausedemo
    Cmd_AddCommand(CF_CLIENT, "pausedemo", CL_PauseDemo_f, "pause demo playback (can also safely pause demo recording if using QUAKE, QUAKEDP or NEHAHRAMOVIE protocol, useful for making movies)");
    Cvar_RegisterVariable (&cl_autodemo);
    Cvar_RegisterVariable (&cl_autodemo_nameformat);
    Cvar_RegisterVariable (&cl_autodemo_delete);
    Cvar_RegisterVariable (&cl_startdemos);
}

References CF_CLIENT, cl_autodemo, cl_autodemo_delete, cl_autodemo_nameformat, CL_Demos_f(), CL_PauseDemo_f(), CL_PlayDemo_f(), CL_Record_f(), cl_startdemos, CL_Startdemos_f(), CL_Stop_f(), CL_Stopdemo_f(), CL_TimeDemo_f(), Cmd_AddCommand(), and Cvar_RegisterVariable().

Referenced by CL_Init().

◆ CL_Disconnect()

void CL_Disconnect ( void )

Definition at line 478 of file cl_main.c.

{
    CL_DisconnectEx(false, NULL);
}

References CL_DisconnectEx(), and NULL.

Referenced by CL_Demos_f(), CL_Disconnect_f(), CL_PlayDemo(), CL_ReadDemoMessage(), CL_Record_f(), CL_Shutdown(), CL_Stopdemo_f(), Curl_Curl_f(), FS_ChangeGameDirs(), and NetConn_ConnectionEstablished().

◆ CL_Disconnect_f()

void CL_Disconnect_f ( cmd_state_t * cmd )

Definition at line 559 of file cl_main.c.

{
    Cmd_Argc(cmd) < 1 ? CL_Disconnect() : CL_DisconnectEx(false, Cmd_Argv(cmd, 1));
}

References CL_Disconnect(), CL_DisconnectEx(), cmd(), Cmd_Argc(), and Cmd_Argv().

Referenced by CL_Init().

◆ CL_DisconnectEx()

void CL_DisconnectEx	(	qbool	kicked,
		const char *	reason,
			... )

Definition at line 370 of file cl_main.c.

{
    va_list argptr;
    char reason[512];
 
    if (cls.state == ca_dedicated)
        return;
 
    if(fmt)
    {
        va_start(argptr,fmt);
        dpvsnprintf(reason,sizeof(reason),fmt,argptr);
        va_end(argptr);
    }
    else
    {
        dpsnprintf(reason, sizeof(reason), "Disconnect by user");
    }
 
    if (Sys_CheckParm("-profilegameonly"))
        Sys_AllowProfiling(false);
 
    Curl_Clear_forthismap();
 
    Con_DPrintf("CL_Disconnect\n");
 
    Cvar_SetValueQuick(&csqc_progcrc, -1);
    Cvar_SetValueQuick(&csqc_progsize, -1);
    CL_VM_ShutDown();
    // stop sounds (especially looping!)
    S_StopAllSounds();
    // prevent dlcache assets from this server from interfering with the next one
    FS_UnloadPacks_dlcache();
 
    cl.parsingtextexpectingpingforscores = 0; // just in case no reply has come yet
 
    // clear contents blends
    cl.cshifts[0].percent = 0;
    cl.cshifts[1].percent = 0;
    cl.cshifts[2].percent = 0;
    cl.cshifts[3].percent = 0;
 
    cl.worldmodel = NULL;
 
    CL_Parse_ErrorCleanUp();
 
    if (cls.demoplayback)
        CL_StopPlayback();
    else if (cls.netcon)
    {
        sizebuf_t buf;
        unsigned char bufdata[520];
        if (cls.demorecording)
            CL_Stop_f(cmd_local);
 
        if(!kicked)
        {
            // send disconnect message 3 times to improve chances of server
            // receiving it (but it still fails sometimes)
            memset(&buf, 0, sizeof(buf));
            buf.data = bufdata;
            buf.maxsize = sizeof(bufdata);
            if (cls.protocol == PROTOCOL_QUAKEWORLD)
            {
                Con_DPrint("Sending drop command\n");
                MSG_WriteByte(&buf, qw_clc_stringcmd);
                MSG_WriteString(&buf, "drop");
            }
            else
            {
                Con_DPrint("Sending clc_disconnect\n");
                MSG_WriteByte(&buf, clc_disconnect);
                if(cls.protocol == PROTOCOL_DARKPLACES8)
                    MSG_WriteString(&buf, reason);
                // DP8 TODO: write a simpler func that Sys_HandleCrash() calls
                // to send a disconnect message indicating we crashed
            }
            NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol, 10000, 0, false);
            NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol, 10000, 0, false);
            NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol, 10000, 0, false);
        }
 
        NetConn_Close(cls.netcon);
        cls.netcon = NULL;
 
        // It's possible for a server to disconnect a player with an empty reason
        // which is checked here rather than above so we don't print "Disconnect by user".
        if(fmt && reason[0] != '\0')
            dpsnprintf(cl_connect_status, sizeof(cl_connect_status), "Disconnect: %s", reason);
        else
            dp_strlcpy(cl_connect_status, "Disconnected", sizeof(cl_connect_status));
        Con_Printf("%s\n", cl_connect_status);
    }
    cls.state = ca_disconnected;
    cl.islocalgame = false;
    cls.signon = 0;
    cls.demoplayback = cls.timedemo = host.restless = false;
    Cvar_Callback(&vid_vsync); // might need to re-enable vsync
 
    Cvar_Callback(&cl_netport);
 
    // If we're dropped mid-connection attempt, it won't clear otherwise.
    SCR_ClearLoadingScreen(false);
 
    if(host.hook.SV_Shutdown)
        host.hook.SV_Shutdown();
}

References buf, ca_dedicated, ca_disconnected, cl, cl_connect_status, cl_netport, CL_Parse_ErrorCleanUp(), CL_Stop_f(), CL_StopPlayback(), CL_VM_ShutDown(), clc_disconnect, cls, cmd_local, Con_DPrint(), Con_DPrintf(), Con_Printf(), client_state_t::cshifts, csqc_progcrc, csqc_progsize, Curl_Clear_forthismap(), Cvar_Callback(), Cvar_SetValueQuick(), client_static_t::demoplayback, client_static_t::demorecording, dp_strlcpy, dpsnprintf(), dpvsnprintf(), FS_UnloadPacks_dlcache(), host_static_t::hook, host, client_state_t::islocalgame, MSG_WriteByte(), MSG_WriteString(), client_static_t::netcon, NetConn_Close(), NetConn_SendUnreliableMessage(), NULL, client_state_t::parsingtextexpectingpingforscores, cshift_t::percent, client_static_t::protocol, PROTOCOL_DARKPLACES8, PROTOCOL_QUAKEWORLD, qw_clc_stringcmd, host_static_t::restless, S_StopAllSounds(), SCR_ClearLoadingScreen(), client_static_t::signon, client_static_t::state, host_static_t::SV_Shutdown, Sys_AllowProfiling(), Sys_CheckParm(), client_static_t::timedemo, vid_vsync, and client_state_t::worldmodel.

Referenced by CL_Disconnect(), CL_Disconnect_f(), CL_Init(), CL_ParseServerMessage(), CL_ReadDemoMessage(), CL_SendMove(), CL_VM_Init(), Host_Error(), and NetConn_ClientFrame().

◆ CL_Effect()

void CL_Effect	(	vec3_t	org,
		model_t *	model,
		int	startframe,
		int	framecount,
		float	framerate )

Definition at line 816 of file cl_main.c.

{
    int i;
    cl_effect_t *e;
    if (!model) // sanity check
        return;
    if (framerate < 1)
    {
        Con_Printf("CL_Effect: framerate %f is < 1\n", framerate);
        return;
    }
    if (framecount < 1)
    {
        Con_Printf("CL_Effect: framecount %i is < 1\n", framecount);
        return;
    }
    for (i = 0, e = cl.effects;i < cl.max_effects;i++, e++)
    {
        if (e->active)
            continue;
        e->active = true;
        VectorCopy(org, e->origin);
        e->model = model;
        e->starttime = cl.time;
        e->startframe = startframe;
        e->endframe = startframe + framecount;
        e->framerate = framerate;
 
        e->frame = 0;
        e->frame1time = cl.time;
        e->frame2time = cl.time;
        cl.num_effects = max(cl.num_effects, i + 1);
        break;
    }
}

References cl_effect_t::active, cl, Con_Printf(), client_state_t::effects, cl_effect_t::endframe, cl_effect_t::frame, cl_effect_t::frame1time, cl_effect_t::frame2time, cl_effect_t::framerate, i, max, client_state_t::max_effects, cl_effect_t::model, model, client_state_t::num_effects, cl_effect_t::origin, cl_effect_t::startframe, cl_effect_t::starttime, client_state_t::time, and VectorCopy.

Referenced by CL_ParseEffect(), CL_ParseEffect2(), CL_ParseTempEntity(), and VM_CL_effect().

◆ CL_EstablishConnection()

void CL_EstablishConnection	(	const char *	host,
		int	firstarg )

Definition at line 574 of file cl_main.c.

{
    if (cls.state == ca_dedicated)
        return;
 
    // don't connect to a server if we're benchmarking a demo
    if (Sys_CheckParm("-benchmark"))
        return;
 
    // make sure the client ports are open before attempting to connect
    NetConn_UpdateSockets();
 
    if (LHNETADDRESS_FromString(&cls.connect_address, address, 26000) && (cls.connect_mysocket = NetConn_ChooseClientSocketForAddress(&cls.connect_address)))
    {
        cls.connect_trying = true;
        cls.connect_remainingtries = 10;
        cls.connect_nextsendtime = 0;
 
        // only NOW, set connect_userinfo
        if(firstarg >= 0)
        {
            int i;
            *cls.connect_userinfo = 0;
            for(i = firstarg; i+2 <= Cmd_Argc(cmd_local); i += 2)
                InfoString_SetValue(cls.connect_userinfo, sizeof(cls.connect_userinfo), Cmd_Argv(cmd_local, i), Cmd_Argv(cmd_local, i+1));
        }
        else if(firstarg < -1)
        {
            // -1: keep as is (reconnect)
            // -2: clear
            *cls.connect_userinfo = 0;
        }
 
        dp_strlcpy(cl_connect_status, "Connect: pending...", sizeof(cl_connect_status));
        SCR_BeginLoadingPlaque(false);
    }
    else
    {
        Con_Printf(CON_ERROR "Connect: failed, unable to find a network socket suitable to reach %s\n", address);
        dp_strlcpy(cl_connect_status, "Connect: failed, no network", sizeof(cl_connect_status));
    }
}

References ca_dedicated, cl_connect_status, cls, Cmd_Argc(), Cmd_Argv(), cmd_local, CON_ERROR, Con_Printf(), client_static_t::connect_address, client_static_t::connect_mysocket, client_static_t::connect_nextsendtime, client_static_t::connect_remainingtries, client_static_t::connect_trying, client_static_t::connect_userinfo, dp_strlcpy, i, InfoString_SetValue(), LHNETADDRESS_FromString(), NetConn_ChooseClientSocketForAddress(), NetConn_UpdateSockets(), SCR_BeginLoadingPlaque(), client_static_t::state, and Sys_CheckParm().

Referenced by CL_Connect_f(), CL_EstablishConnection_Local(), and CL_Reconnect_f().

◆ CL_ExpandCSQCRenderEntities()

void CL_ExpandCSQCRenderEntities ( int num )

Definition at line 325 of file cl_main.c.

{
    int i;
    int oldmaxcsqcrenderentities;
    entity_render_t *oldcsqcrenderentities;
    if (num >= cl.max_csqcrenderentities)
    {
        if (num >= MAX_EDICTS)
            Host_Error("CL_ExpandEntities: num %i >= %i", num, MAX_EDICTS);
        oldmaxcsqcrenderentities = cl.max_csqcrenderentities;
        oldcsqcrenderentities = cl.csqcrenderentities;
        cl.max_csqcrenderentities = (num & ~255) + 256;
        cl.csqcrenderentities = (entity_render_t *)Mem_Alloc(cls.levelmempool, cl.max_csqcrenderentities * sizeof(entity_render_t));
        if (oldcsqcrenderentities)
        {
            memcpy(cl.csqcrenderentities, oldcsqcrenderentities, oldmaxcsqcrenderentities * sizeof(entity_render_t));
            for (i = 0;i < r_refdef.scene.numentities;i++)
                if(r_refdef.scene.entities[i] >= oldcsqcrenderentities && r_refdef.scene.entities[i] < (oldcsqcrenderentities + oldmaxcsqcrenderentities))
                    r_refdef.scene.entities[i] = cl.csqcrenderentities + (r_refdef.scene.entities[i] - oldcsqcrenderentities);
            Mem_Free(oldcsqcrenderentities);
        }
    }
}

References cl, cls, client_state_t::csqcrenderentities, r_refdef_scene_t::entities, Host_Error(), i, client_static_t::levelmempool, client_state_t::max_csqcrenderentities, MAX_EDICTS, Mem_Alloc, Mem_Free, r_refdef_scene_t::numentities, r_refdef, and r_refdef_t::scene.

Referenced by CLVM_init_edict().

◆ CL_ExpandEntities()

void CL_ExpandEntities ( int num )

Definition at line 300 of file cl_main.c.

{
    int i, oldmaxentities;
    entity_t *oldentities;
    if (num >= cl.max_entities)
    {
        if (!cl.entities)
            Sys_Error("CL_ExpandEntities: cl.entities not initialized");
        if (num >= MAX_EDICTS)
            Host_Error("CL_ExpandEntities: num %i >= %i", num, MAX_EDICTS);
        oldmaxentities = cl.max_entities;
        oldentities = cl.entities;
        cl.max_entities = (num & ~255) + 256;
        cl.entities = (entity_t *)Mem_Alloc(cls.levelmempool, cl.max_entities * sizeof(entity_t));
        memcpy(cl.entities, oldentities, oldmaxentities * sizeof(entity_t));
        Mem_Free(oldentities);
        for (i = oldmaxentities;i < cl.max_entities;i++)
        {
            cl.entities[i].state_baseline = defaultstate;
            cl.entities[i].state_previous = defaultstate;
            cl.entities[i].state_current = defaultstate;
        }
    }
}

References cl, cls, defaultstate, client_state_t::entities, Host_Error(), i, client_static_t::levelmempool, MAX_EDICTS, client_state_t::max_entities, Mem_Alloc, Mem_Free, entity_t::state_baseline, entity_t::state_current, entity_t::state_previous, and Sys_Error().

Referenced by CL_NewBeam(), CL_ParseServerMessage(), CL_ParseStartSoundPacket(), CL_ParseTrailParticles(), EntityFrame4_CL_ReadFrame(), EntityFrame5_CL_ReadFrame(), EntityFrame_CL_ReadFrame(), EntityFrameQuake_ReadEntity(), and EntityFrameQW_CL_ReadFrame().

◆ CL_FindNonSolidLocation()

void CL_FindNonSolidLocation	(	const vec3_t	in,
		vec3_t	out,
		vec_t	radius )

Definition at line 79 of file cl_collision.c.

{
    // FIXME: check multiple brush models
    if (cl.worldmodel && cl.worldmodel->brush.FindNonSolidLocation)
        cl.worldmodel->brush.FindNonSolidLocation(cl.worldmodel, in, out, radius);
}

References cl, and client_state_t::worldmodel.

Referenced by CL_AllocLightFlash(), CL_ParseTempEntity(), VM_CL_te_blood(), VM_CL_te_customflash(), VM_CL_te_explosion(), VM_CL_te_explosion2(), VM_CL_te_explosionquad(), VM_CL_te_explosionrgb(), VM_CL_te_flamejet(), VM_CL_te_gunshot(), VM_CL_te_gunshotquad(), VM_CL_te_knightspike(), VM_CL_te_plasmaburn(), VM_CL_te_smallflash(), VM_CL_te_spark(), VM_CL_te_spike(), VM_CL_te_spikequad(), VM_CL_te_superspike(), VM_CL_te_superspikequad(), VM_CL_te_tarexplosion(), and VM_CL_te_wizspike().

◆ CL_ForwardToServer()

void CL_ForwardToServer ( const char * s )

adds the string as a clc_stringcmd to the client message.

(used when there is no reason to generate a local command to do it)

Definition at line 54 of file cl_cmd.c.

{
    char temp[128];
    if (cls.state != ca_connected)
    {
        Con_Printf("Can't \"%s\", not connected\n", s);
        return;
    }
 
    if (!cls.netcon)
        return;
 
    // LadyHavoc: thanks to Fuh for bringing the pure evil of SZ_Print to my
    // attention, it has been eradicated from here, its only (former) use in
    // all of darkplaces.
    if (cls.protocol == PROTOCOL_QUAKEWORLD)
        MSG_WriteByte(&cls.netcon->message, qw_clc_stringcmd);
    else
        MSG_WriteByte(&cls.netcon->message, clc_stringcmd);
    if ((!strncmp(s, "say ", 4) || !strncmp(s, "say_team ", 9)) && cl_locs_enable.integer)
    {
        // say/say_team commands can replace % character codes with status info
        while (*s)
        {
            if (*s == '%' && s[1])
            {
                // handle proquake message macros
                temp[0] = 0;
                switch (s[1])
                {
                case 'l': // current location
                    CL_Locs_FindLocationName(temp, sizeof(temp), cl.movement_origin);
                    break;
                case 'h': // current health
                    dpsnprintf(temp, sizeof(temp), "%i", cl.stats[STAT_HEALTH]);
                    break;
                case 'a': // current armor
                    dpsnprintf(temp, sizeof(temp), "%i", cl.stats[STAT_ARMOR]);
                    break;
                case 'x': // current rockets
                    dpsnprintf(temp, sizeof(temp), "%i", cl.stats[STAT_ROCKETS]);
                    break;
                case 'c': // current cells
                    dpsnprintf(temp, sizeof(temp), "%i", cl.stats[STAT_CELLS]);
                    break;
                // silly proquake macros
                case 'd': // loc at last death
                    CL_Locs_FindLocationName(temp, sizeof(temp), cl.lastdeathorigin);
                    break;
                case 't': // current time
                    dpsnprintf(temp, sizeof(temp), "%.0f:%.0f", floor(cl.time / 60), cl.time - floor(cl.time / 60) * 60);
                    break;
                case 'r': // rocket launcher status ("I have RL", "I need rockets", "I need RL")
                    if (!(cl.stats[STAT_ITEMS] & IT_ROCKET_LAUNCHER))
                        dpsnprintf(temp, sizeof(temp), "I need RL");
                    else if (!cl.stats[STAT_ROCKETS])
                        dpsnprintf(temp, sizeof(temp), "I need rockets");
                    else
                        dpsnprintf(temp, sizeof(temp), "I have RL");
                    break;
                case 'p': // powerup status (outputs "quad" "pent" and "eyes" according to status)
                    if (cl.stats[STAT_ITEMS] & IT_QUAD)
                    {
                        if (temp[0])
                            dp_strlcat(temp, " ", sizeof(temp));
                        dp_strlcat(temp, "quad", sizeof(temp));
                    }
                    if (cl.stats[STAT_ITEMS] & IT_INVULNERABILITY)
                    {
                        if (temp[0])
                            dp_strlcat(temp, " ", sizeof(temp));
                        dp_strlcat(temp, "pent", sizeof(temp));
                    }
                    if (cl.stats[STAT_ITEMS] & IT_INVISIBILITY)
                    {
                        if (temp[0])
                            dp_strlcat(temp, " ", sizeof(temp));
                        dp_strlcat(temp, "eyes", sizeof(temp));
                    }
                    break;
                case 'w': // weapon status (outputs "SSG:NG:SNG:GL:RL:LG" with the text between : characters omitted if you lack the weapon)
                    if (cl.stats[STAT_ITEMS] & IT_SUPER_SHOTGUN)
                        dp_strlcat(temp, "SSG", sizeof(temp));
                    dp_strlcat(temp, ":", sizeof(temp));
                    if (cl.stats[STAT_ITEMS] & IT_NAILGUN)
                        dp_strlcat(temp, "NG", sizeof(temp));
                    dp_strlcat(temp, ":", sizeof(temp));
                    if (cl.stats[STAT_ITEMS] & IT_SUPER_NAILGUN)
                        dp_strlcat(temp, "SNG", sizeof(temp));
                    dp_strlcat(temp, ":", sizeof(temp));
                    if (cl.stats[STAT_ITEMS] & IT_GRENADE_LAUNCHER)
                        dp_strlcat(temp, "GL", sizeof(temp));
                    dp_strlcat(temp, ":", sizeof(temp));
                    if (cl.stats[STAT_ITEMS] & IT_ROCKET_LAUNCHER)
                        dp_strlcat(temp, "RL", sizeof(temp));
                    dp_strlcat(temp, ":", sizeof(temp));
                    if (cl.stats[STAT_ITEMS] & IT_LIGHTNING)
                        dp_strlcat(temp, "LG", sizeof(temp));
                    break;
                default:
                    // not a recognized macro, print it as-is...
                    temp[0] = s[0];
                    temp[1] = s[1];
                    temp[2] = 0;
                    break;
                }
                // write the resulting text
                SZ_Write(&cls.netcon->message, (unsigned char *)temp, (int)strlen(temp));
                s += 2;
                continue;
            }
            MSG_WriteByte(&cls.netcon->message, *s);
            s++;
        }
        MSG_WriteByte(&cls.netcon->message, 0);
    }
    else // any other command is passed on as-is
        SZ_Write(&cls.netcon->message, (const unsigned char *)s, (int)strlen(s) + 1);
}

References ca_connected, cl, cl_locs_enable, CL_Locs_FindLocationName(), clc_stringcmd, cls, Con_Printf(), dp_strlcat, dpsnprintf(), floor(), cvar_t::integer, IT_GRENADE_LAUNCHER, IT_INVISIBILITY, IT_INVULNERABILITY, IT_LIGHTNING, IT_NAILGUN, IT_QUAD, IT_ROCKET_LAUNCHER, IT_SUPER_NAILGUN, IT_SUPER_SHOTGUN, client_state_t::lastdeathorigin, netconn_t::message, client_state_t::movement_origin, MSG_WriteByte(), client_static_t::netcon, client_static_t::protocol, PROTOCOL_QUAKEWORLD, qw_clc_stringcmd, STAT_ARMOR, STAT_CELLS, STAT_HEALTH, STAT_ITEMS, STAT_ROCKETS, client_static_t::state, client_state_t::stats, strlen(), SZ_Write(), and client_state_t::time.

Referenced by CL_BeginDownloads(), CL_DownloadBegin_f(), CL_ForwardToServer_f(), CL_SendCvar_f(), Key_Message(), and NetConn_ConnectionEstablished().

◆ CL_ForwardToServer_f()

void CL_ForwardToServer_f ( cmd_state_t * cmd )

adds the current command line as a clc_stringcmd to the client message.

things like godmode, noclip, etc, are commands directed to the server, so when they are typed in at the console, they will need to be forwarded.

Definition at line 174 of file cl_cmd.c.

{
    const char *s;
    char vabuf[MAX_INPUTLINE];
    size_t i;
    if (!strcasecmp(Cmd_Argv(cmd, 0), "cmd"))
    {
        // we want to strip off "cmd", so just send the args
        s = Cmd_Argc(cmd) > 1 ? Cmd_Args(cmd) : "";
    }
    else
    {
        // we need to keep the command name, so send Cmd_Argv(cmd, 0), a space and then Cmd_Args(cmd)
        i = dpsnprintf(vabuf, sizeof(vabuf), "%s", Cmd_Argv(cmd, 0));
        if(Cmd_Argc(cmd) > 1)
            // (i + 1) accounts for the added space
            dpsnprintf(&vabuf[i], sizeof(vabuf) - (i + 1), " %s", Cmd_Args(cmd));
        s = vabuf;
    }
    // don't send an empty forward message if the user tries "cmd" by itself
    if (!s || !*s)
        return;
    CL_ForwardToServer(s);
}

References CL_ForwardToServer(), cmd(), Cmd_Argc(), Cmd_Args(), Cmd_Argv(), dpsnprintf(), i, and MAX_INPUTLINE.

Referenced by CL_InitCommands(), and Cmd_CL_Callback().

◆ CL_Frame()

double CL_Frame ( double time )

Definition at line 2802 of file cl_main.c.

{
    static double clframetime;
    static double cl_timer = 0;
    static double time1 = 0, time2 = 0, time3 = 0;
    int pass1, pass2, pass3;
    float maxfps;
 
    CL_VM_PreventInformationLeaks();
 
    /*
     * If the accumulator hasn't become positive, don't
     * run the frame. Everything that happens before this
     * point will happen even if we're sleeping this frame.
     */
 
    // limit the frametime steps to no more than 100ms each
    cl_timer = min(cl_timer + time, 0.1);
 
    // Run at full speed when querying servers, compared to waking up early to parse
    // this is simpler and gives pings more representative of what can be expected when playing.
    maxfps = (vid_activewindow || serverlist_querystage ? cl_maxfps : cl_maxidlefps).value;
 
    if (cls.state != ca_dedicated && (cl_timer > 0 || host.restless || maxfps <= 0))
    {
        R_TimeReport("---");
        Collision_Cache_NewFrame();
        R_TimeReport("photoncache");
#ifdef CONFIG_VIDEO_CAPTURE
        // decide the simulation time
        if (cls.capturevideo.active)
        {
            if (cls.capturevideo.realtime)
                clframetime = cl.realframetime = max(time, 1.0 / cls.capturevideo.framerate);
            else
            {
                clframetime = 1.0 / cls.capturevideo.framerate;
                cl.realframetime = max(time, clframetime);
            }
        }
        else
#endif
        {
            if (maxfps <= 0 || cls.timedemo)
                clframetime = cl.realframetime = cl_timer;
            else
                // networking assumes at least 10fps
                clframetime = cl.realframetime = bound(cl_timer, 1 / maxfps, 0.1);
 
            // on some legacy systems, we need to sleep to keep input responsive
            if (cl_maxfps_alwayssleep.value > 0 && !cls.timedemo)
                Sys_Sleep(min(cl_maxfps_alwayssleep.value / 1000, 0.05));
        }
 
        // apply slowmo scaling
        clframetime *= cl.movevars_timescale;
        // scale playback speed of demos by slowmo cvar
        if (cls.demoplayback)
        {
            clframetime *= host_timescale.value;
            // if demo playback is paused, don't advance time at all
            if (cls.demopaused)
                clframetime = 0;
        }
        else
        {
            // host_framerate overrides all else
            if (host_framerate.value)
                clframetime = host_framerate.value;
 
            if (cl.paused || host.paused)
                clframetime = 0;
        }
 
        // deduct the frame time from the accumulator
        cl_timer -= cl.realframetime;
 
        cl.oldtime = cl.time;
        cl.time += clframetime;
 
        // update video
        if (host_speeds.integer)
            time1 = Sys_DirtyTime();
        R_TimeReport("pre-input");
 
        // Collect input into cmd
        CL_Input();
 
        R_TimeReport("input");
 
        // check for new packets
        NetConn_ClientFrame();
 
        // read a new frame from a demo if needed
        CL_ReadDemoMessage();
        R_TimeReport("clientnetwork");
 
        // now that packets have been read, send input to server
        CL_SendMove();
        R_TimeReport("sendmove");
 
        // update client world (interpolate entities, create trails, etc)
        CL_UpdateWorld();
        R_TimeReport("lerpworld");
 
        CL_Video_Frame();
 
        R_TimeReport("client");
 
        CL_UpdateScreen();
        R_TimeReport("render");
 
        if (host_speeds.integer)
            time2 = Sys_DirtyTime();
 
        // update audio
        if(cl.csqc_usecsqclistener)
        {
            S_Update(&cl.csqc_listenermatrix);
            cl.csqc_usecsqclistener = false;
        }
        else
            S_Update(&r_refdef.view.matrix);
 
        CDAudio_Update();
        R_TimeReport("audio");
 
        // reset gathering of mouse input
        in_mouse_x = in_mouse_y = 0;
 
        if (host_speeds.integer)
        {
            pass1 = (int)((time1 - time3)*1000000);
            time3 = Sys_DirtyTime();
            pass2 = (int)((time2 - time1)*1000000);
            pass3 = (int)((time3 - time2)*1000000);
            Con_Printf("%6ius total %6ius server %6ius gfx %6ius snd\n",
                        pass1+pass2+pass3, pass1, pass2, pass3);
        }
    }
    // if there is some time remaining from this frame, reset the timer
    return cl_timer >= 0 ? 0 : cl_timer;
}

References bound, ca_dedicated, CDAudio_Update(), cl, CL_Input(), cl_maxfps, cl_maxfps_alwayssleep, cl_maxidlefps, CL_ReadDemoMessage(), CL_SendMove(), CL_UpdateScreen(), CL_UpdateWorld(), CL_Video_Frame(), CL_VM_PreventInformationLeaks(), cls, Collision_Cache_NewFrame(), Con_Printf(), client_state_t::csqc_listenermatrix, client_state_t::csqc_usecsqclistener, client_static_t::demopaused, client_static_t::demoplayback, host, host_framerate, host_speeds, host_timescale, in_mouse_x, in_mouse_y, int(), cvar_t::integer, r_refdef_view_t::matrix, max, min, client_state_t::movevars_timescale, NetConn_ClientFrame(), client_state_t::oldtime, client_state_t::paused, host_static_t::paused, r_refdef, R_TimeReport(), client_state_t::realframetime, host_static_t::restless, S_Update(), serverlist_querystage, client_static_t::state, Sys_DirtyTime(), Sys_Sleep(), client_state_t::time, time, client_static_t::timedemo, cvar_t::value, value, vid_activewindow, and r_refdef_t::view.

Referenced by Host_Frame().

◆ CL_Init()

void CL_Init ( void )

Definition at line 2988 of file cl_main.c.

{
    if (cls.state == ca_dedicated)
    {
        Cmd_AddCommand(CF_SERVER, "disconnect", CL_Disconnect_f, "disconnect from server (or disconnect all clients if running a server)");
    }
    else
    {
        Con_Printf("Initializing client\n");
 
        Cvar_SetValueQuick(&host_isclient, 1);
 
        R_Modules_Init();
        Palette_Init();
#ifdef CONFIG_MENU
        MR_Init_Commands();
#endif
        VID_Shared_Init();
        VID_Init();
        Render_Init();
        S_Init();
        Key_Init();
        V_Init();
 
        cls.levelmempool = Mem_AllocPool("client (per-level memory)", 0, NULL);
        cls.permanentmempool = Mem_AllocPool("client (long term memory)", 0, NULL);
 
        memset(&r_refdef, 0, sizeof(r_refdef));
        // max entities sent to renderer per frame
        r_refdef.scene.maxentities = MAX_EDICTS + 256 + 512;
        r_refdef.scene.entities = (entity_render_t **)Mem_Alloc(cls.permanentmempool, sizeof(entity_render_t *) * r_refdef.scene.maxentities);
 
        // max temp entities
        r_refdef.scene.maxtempentities = MAX_TEMPENTITIES;
        r_refdef.scene.tempentities = (entity_render_t *)Mem_Alloc(cls.permanentmempool, sizeof(entity_render_t) * r_refdef.scene.maxtempentities);
 
        CL_InitInput ();
 
    //
    // register our commands
    //
        CL_InitCommands();
 
        Cvar_RegisterVariable (&cl_upspeed);
        Cvar_RegisterVariable (&cl_forwardspeed);
        Cvar_RegisterVariable (&cl_backspeed);
        Cvar_RegisterVariable (&cl_sidespeed);
        Cvar_RegisterVariable (&cl_movespeedkey);
        Cvar_RegisterVariable (&cl_yawspeed);
        Cvar_RegisterVariable (&cl_pitchspeed);
        Cvar_RegisterVariable (&cl_anglespeedkey);
        Cvar_RegisterVariable (&cl_shownet);
        Cvar_RegisterVariable (&cl_nolerp);
        Cvar_RegisterVariable (&cl_lerpexcess);
        Cvar_RegisterVariable (&cl_lerpanim_maxdelta_server);
        Cvar_RegisterVariable (&cl_lerpanim_maxdelta_framegroups);
        Cvar_RegisterVariable (&cl_deathfade);
        Cvar_RegisterVariable (&lookspring);
        Cvar_RegisterVariable (&lookstrafe);
        Cvar_RegisterVariable (&sensitivity);
        Cvar_RegisterVariable (&freelook);
 
        Cvar_RegisterVariable (&m_pitch);
        Cvar_RegisterVariable (&m_yaw);
        Cvar_RegisterVariable (&m_forward);
        Cvar_RegisterVariable (&m_side);
 
        Cvar_RegisterVariable (&cl_itembobspeed);
        Cvar_RegisterVariable (&cl_itembobheight);
 
        CL_Demo_Init();
 
        Cmd_AddCommand(CF_CLIENT, "entities", CL_PrintEntities_f, "print information on network entities known to client");
        Cmd_AddCommand(CF_CLIENT, "disconnect", CL_Disconnect_f, "disconnect from server (or disconnect all clients if running a server)");
        Cmd_AddCommand(CF_CLIENT, "connect", CL_Connect_f, "connect to a server by IP address or hostname");
        Cmd_AddCommand(CF_CLIENT | CF_CLIENT_FROM_SERVER, "reconnect", CL_Reconnect_f, "reconnect to the last server you were on, or resets a quakeworld connection (do not use if currently playing on a netquake server)");
 
        // Support Client-side Model Index List
        Cmd_AddCommand(CF_CLIENT, "cl_modelindexlist", CL_ModelIndexList_f, "list information on all models in the client modelindex");
        // Support Client-side Sound Index List
        Cmd_AddCommand(CF_CLIENT, "cl_soundindexlist", CL_SoundIndexList_f, "list all sounds in the client soundindex");
 
        Cmd_AddCommand(CF_CLIENT, "fog", CL_Fog_f, "set global fog parameters (density red green blue [alpha [mindist [maxdist [top [fadedepth]]]]])");
        Cmd_AddCommand(CF_CLIENT, "fog_heighttexture", CL_Fog_HeightTexture_f, "set global fog parameters (density red green blue alpha mindist maxdist top depth textures/mapname/fogheight.tga)");
 
        Cmd_AddCommand(CF_CLIENT, "cl_areastats", CL_AreaStats_f, "prints statistics on entity culling during collision traces");
 
        Cvar_RegisterVariable(&r_draweffects);
        Cvar_RegisterVariable(&cl_explosions_alpha_start);
        Cvar_RegisterVariable(&cl_explosions_alpha_end);
        Cvar_RegisterVariable(&cl_explosions_size_start);
        Cvar_RegisterVariable(&cl_explosions_size_end);
        Cvar_RegisterVariable(&cl_explosions_lifetime);
        Cvar_RegisterVariable(&cl_stainmaps);
        Cvar_RegisterVariable(&cl_stainmaps_clearonload);
        Cvar_RegisterVariable(&cl_beams_polygons);
        Cvar_RegisterVariable(&cl_beams_quakepositionhack);
        Cvar_RegisterVariable(&cl_beams_instantaimhack);
        Cvar_RegisterVariable(&cl_beams_lightatend);
        Cvar_RegisterVariable(&cl_noplayershadow);
        Cvar_RegisterVariable(&cl_dlights_decayradius);
        Cvar_RegisterVariable(&cl_dlights_decaybrightness);
 
        Cvar_RegisterVariable(&cl_prydoncursor);
        Cvar_RegisterVariable(&cl_prydoncursor_notrace);
 
        Cvar_RegisterVariable(&cl_deathnoviewmodel);
 
        // for QW connections
        Cvar_RegisterVariable(&qport);
        // multiplying by RAND_MAX necessary for Windows, for which RAND_MAX is only 32767.
        Cvar_SetValueQuick(&qport, ((unsigned int)rand() * RAND_MAX + (unsigned int)rand()) & 0xffff);
 
        Cmd_AddCommand(CF_CLIENT, "timerefresh", CL_TimeRefresh_f, "turn quickly and print rendering statistcs");
 
        Cvar_RegisterVariable(&cl_locs_enable);
        Cvar_RegisterVariable(&cl_locs_show);
        Cmd_AddCommand(CF_CLIENT, "locs_add", CL_Locs_Add_f, "add a point or box location (usage: x y z[ x y z] \"name\", if two sets of xyz are supplied it is a box, otherwise point)");
        Cmd_AddCommand(CF_CLIENT, "locs_removenearest", CL_Locs_RemoveNearest_f, "remove the nearest point or box (note: you need to be very near a box to remove it)");
        Cmd_AddCommand(CF_CLIENT, "locs_clear", CL_Locs_Clear_f, "remove all loc points/boxes");
        Cmd_AddCommand(CF_CLIENT, "locs_reload", CL_Locs_Reload_f, "reload .loc file for this map");
        Cmd_AddCommand(CF_CLIENT, "locs_save", CL_Locs_Save_f, "save .loc file for this map containing currently defined points and boxes");
 
        Cvar_RegisterVariable(&csqc_polygons_defaultmaterial_nocullface);
        Cvar_RegisterVariable(&csqc_lowres);
 
        Cvar_RegisterVariable (&cl_minfps);
        Cvar_RegisterVariable (&cl_minfps_fade);
        Cvar_RegisterVariable (&cl_minfps_qualitymax);
        Cvar_RegisterVariable (&cl_minfps_qualitymin);
        Cvar_RegisterVariable (&cl_minfps_qualitystepmax);
        Cvar_RegisterVariable (&cl_minfps_qualityhysteresis);
        Cvar_RegisterVariable (&cl_minfps_qualitymultiply);
        Cvar_RegisterVariable (&cl_minfps_force);
        Cvar_RegisterVariable (&cl_maxfps);
        Cvar_RegisterVariable (&cl_maxfps_alwayssleep);
        Cvar_RegisterVariable (&cl_maxidlefps);
 
        Cvar_RegisterVariable (&cl_areagrid_link_SOLID_NOT);
        Cvar_RegisterVariable (&cl_gameplayfix_nudgeoutofsolid_separation);
 
        CL_Parse_Init();
        CL_Particles_Init();
        CL_Screen_Init();
 
        CL_Video_Init();
 
        Cvar_Callback(&cl_netport);
 
        host.hook.ConnectLocal = CL_EstablishConnection_Local;
        host.hook.Disconnect = CL_DisconnectEx;
        host.hook.ToggleMenu = CL_ToggleMenu_Hook;
    }
}

References ca_dedicated, CF_CLIENT, CF_CLIENT_FROM_SERVER, CF_SERVER, cl_anglespeedkey, cl_areagrid_link_SOLID_NOT, CL_AreaStats_f(), cl_backspeed, cl_beams_instantaimhack, cl_beams_lightatend, cl_beams_polygons, cl_beams_quakepositionhack, CL_Connect_f(), cl_deathfade, cl_deathnoviewmodel, CL_Demo_Init(), CL_Disconnect_f(), CL_DisconnectEx(), cl_dlights_decaybrightness, cl_dlights_decayradius, CL_EstablishConnection_Local(), cl_explosions_alpha_end, cl_explosions_alpha_start, cl_explosions_lifetime, cl_explosions_size_end, cl_explosions_size_start, CL_Fog_f(), CL_Fog_HeightTexture_f(), cl_forwardspeed, cl_gameplayfix_nudgeoutofsolid_separation, CL_InitCommands(), CL_InitInput(), cl_itembobheight, cl_itembobspeed, cl_lerpanim_maxdelta_framegroups, cl_lerpanim_maxdelta_server, cl_lerpexcess, CL_Locs_Add_f(), CL_Locs_Clear_f(), cl_locs_enable, CL_Locs_Reload_f(), CL_Locs_RemoveNearest_f(), CL_Locs_Save_f(), cl_locs_show, cl_maxfps, cl_maxfps_alwayssleep, cl_maxidlefps, cl_minfps, cl_minfps_fade, cl_minfps_force, cl_minfps_qualityhysteresis, cl_minfps_qualitymax, cl_minfps_qualitymin, cl_minfps_qualitymultiply, cl_minfps_qualitystepmax, CL_ModelIndexList_f(), cl_movespeedkey, cl_netport, cl_nolerp, cl_noplayershadow, CL_Parse_Init(), CL_Particles_Init(), cl_pitchspeed, CL_PrintEntities_f(), cl_prydoncursor, cl_prydoncursor_notrace, CL_Reconnect_f(), CL_Screen_Init(), cl_shownet, cl_sidespeed, CL_SoundIndexList_f(), cl_stainmaps, cl_stainmaps_clearonload, CL_TimeRefresh_f(), CL_ToggleMenu_Hook(), cl_upspeed, CL_Video_Init(), cl_yawspeed, cls, Cmd_AddCommand(), Con_Printf(), host_static_t::ConnectLocal, csqc_lowres, csqc_polygons_defaultmaterial_nocullface, Cvar_Callback(), Cvar_RegisterVariable(), Cvar_SetValueQuick(), host_static_t::Disconnect, r_refdef_scene_t::entities, freelook, host_static_t::hook, host, host_isclient, Key_Init(), client_static_t::levelmempool, lookspring, lookstrafe, m_forward, m_pitch, m_side, m_yaw, MAX_EDICTS, MAX_TEMPENTITIES, r_refdef_scene_t::maxentities, r_refdef_scene_t::maxtempentities, Mem_Alloc, Mem_AllocPool, MR_Init_Commands(), NULL, Palette_Init(), client_static_t::permanentmempool, qport, r_draweffects, R_Modules_Init(), r_refdef, Render_Init(), S_Init(), r_refdef_t::scene, sensitivity, client_static_t::state, r_refdef_scene_t::tempentities, host_static_t::ToggleMenu, V_Init(), VID_Init(), and VID_Shared_Init().

Referenced by Host_Init().

◆ CL_InitCommands()

void CL_InitCommands ( void )

Definition at line 742 of file cl_cmd.c.

{
    dpsnprintf(cls.userinfo, sizeof(cls.userinfo), "\\name\\player\\team\\none\\topcolor\\0\\bottomcolor\\0\\rate\\10000\\msg\\1\\noaim\\1\\*ver\\dp");
 
    /* In Quake `name` is a command that concatenates its arguments (quotes unnecessary)
     * which is expected in most DP-based games.
     * In QuakeWorld it's a cvar which requires quotes if spaces are used.
     */
    Cvar_RegisterVariable(&cl_name);
    if ((0)) // TODO: if (gamemode == GAME_QUAKEWORLD)
        Cvar_RegisterVirtual(&cl_name, "name");
    else
        Cmd_AddCommand(CF_CLIENT, "name", CL_Name_f, "change your player name");
 
    Cvar_RegisterVariable(&cl_rate);
    Cvar_RegisterVirtual(&cl_rate, "_cl_rate");
    Cvar_RegisterVariable(&cl_rate_burstsize);
    Cvar_RegisterVirtual(&cl_rate_burstsize, "_cl_rate_burstsize");
    Cvar_RegisterVariable(&cl_pmodel);
    Cvar_RegisterVirtual(&cl_pmodel, "_cl_pmodel");
    Cvar_RegisterVariable(&cl_color);
    Cvar_RegisterCallback(&cl_color, CL_Color_c);
    Cvar_RegisterVariable(&cl_topcolor);
    Cvar_RegisterCallback(&cl_topcolor, CL_Topcolor_c);
    Cvar_RegisterVariable(&cl_bottomcolor);
    Cvar_RegisterCallback(&cl_bottomcolor, CL_Bottomcolor_c);
    Cvar_RegisterVariable(&r_fixtrans_auto);
    Cvar_RegisterVariable(&cl_team);
    Cvar_RegisterVariable(&cl_skin);
    Cvar_RegisterVariable(&cl_noaim);   
 
    Cmd_AddCommand(CF_CLIENT | CF_CLIENT_FROM_SERVER, "cmd", CL_ForwardToServer_f, "send a console commandline to the server (used by some mods)");
    Cmd_AddCommand(CF_CLIENT, "color", CL_Color_f, "change your player shirt and pants colors");
    Cmd_AddCommand(CF_CLIENT, "rcon", CL_Rcon_f, "sends a command to the server console (if your rcon_password matches the server's rcon_password), or to the address specified by rcon_address when not connected (again rcon_password must match the server's); note: if rcon_secure is set, client and server clocks must be synced e.g. via NTP");
    Cmd_AddCommand(CF_CLIENT, "srcon", CL_Rcon_f, "sends a command to the server console (if your rcon_password matches the server's rcon_password), or to the address specified by rcon_address when not connected (again rcon_password must match the server's); this always works as if rcon_secure is set; note: client and server clocks must be synced e.g. via NTP");
    Cmd_AddCommand(CF_CLIENT, "pqrcon", CL_PQRcon_f, "sends a command to a proquake server console (if your rcon_password matches the server's rcon_password), or to the address specified by rcon_address when not connected (again rcon_password must match the server's)");
    Cmd_AddCommand(CF_SHARED, "user", CL_User_f, "prints additional information about a player number or name on the scoreboard");
    Cmd_AddCommand(CF_SHARED, "users", CL_Users_f, "prints additional information about all players on the scoreboard");
    Cmd_AddCommand(CF_CLIENT, "packet", CL_Packet_f, "send a packet to the specified address:port containing a text string");
    Cmd_AddCommand(CF_CLIENT, "fullinfo", CL_FullInfo_f, "allows client to modify their userinfo");
    Cmd_AddCommand(CF_CLIENT, "setinfo", CL_SetInfo_f, "modifies your userinfo");
    Cmd_AddCommand(CF_CLIENT, "fixtrans", Image_FixTransparentPixels_f, "change alpha-zero pixels in an image file to sensible values, and write out a new TGA (warning: SLOW)");
    host.hook.CL_SendCvar = CL_SendCvar_f;
 
    // commands that are only sent by server to client for execution
    Cmd_AddCommand(CF_CLIENT_FROM_SERVER, "pingplreport", CL_PingPLReport_f, "command sent by server containing client ping and packet loss values for scoreboard, triggered by pings command from client (not used by QW servers)");
    Cmd_AddCommand(CF_CLIENT_FROM_SERVER, "fullserverinfo", CL_FullServerinfo_f, "internal use only, sent by server to client to update client's local copy of serverinfo string");
}

References CF_CLIENT, CF_CLIENT_FROM_SERVER, CF_SHARED, cl_bottomcolor, CL_Bottomcolor_c(), cl_color, CL_Color_c(), CL_Color_f(), CL_ForwardToServer_f(), CL_FullInfo_f(), CL_FullServerinfo_f(), cl_name, CL_Name_f(), cl_noaim, CL_Packet_f(), CL_PingPLReport_f(), cl_pmodel, CL_PQRcon_f(), cl_rate, cl_rate_burstsize, CL_Rcon_f(), host_static_t::CL_SendCvar, CL_SendCvar_f(), CL_SetInfo_f(), cl_skin, cl_team, cl_topcolor, CL_Topcolor_c(), CL_User_f(), CL_Users_f(), cls, Cmd_AddCommand(), Cvar_RegisterCallback(), Cvar_RegisterVariable(), Cvar_RegisterVirtual(), dpsnprintf(), host_static_t::hook, host, Image_FixTransparentPixels_f(), r_fixtrans_auto, and client_static_t::userinfo.

Referenced by CL_Init().

◆ CL_InitInput()

void CL_InitInput ( void )

Definition at line 2209 of file cl_input.c.

{
    Cmd_AddCommand(CF_CLIENT, "+moveup",IN_UpDown, "swim upward");
    Cmd_AddCommand(CF_CLIENT, "-moveup",IN_UpUp, "stop swimming upward");
    Cmd_AddCommand(CF_CLIENT, "+movedown",IN_DownDown, "swim downward");
    Cmd_AddCommand(CF_CLIENT, "-movedown",IN_DownUp, "stop swimming downward");
    Cmd_AddCommand(CF_CLIENT, "+left",IN_LeftDown, "turn left");
    Cmd_AddCommand(CF_CLIENT, "-left",IN_LeftUp, "stop turning left");
    Cmd_AddCommand(CF_CLIENT, "+right",IN_RightDown, "turn right");
    Cmd_AddCommand(CF_CLIENT, "-right",IN_RightUp, "stop turning right");
    Cmd_AddCommand(CF_CLIENT, "+forward",IN_ForwardDown, "move forward");
    Cmd_AddCommand(CF_CLIENT, "-forward",IN_ForwardUp, "stop moving forward");
    Cmd_AddCommand(CF_CLIENT, "+back",IN_BackDown, "move backward");
    Cmd_AddCommand(CF_CLIENT, "-back",IN_BackUp, "stop moving backward");
    Cmd_AddCommand(CF_CLIENT, "+lookup", IN_LookupDown, "look upward");
    Cmd_AddCommand(CF_CLIENT, "-lookup", IN_LookupUp, "stop looking upward");
    Cmd_AddCommand(CF_CLIENT, "+lookdown", IN_LookdownDown, "look downward");
    Cmd_AddCommand(CF_CLIENT, "-lookdown", IN_LookdownUp, "stop looking downward");
    Cmd_AddCommand(CF_CLIENT, "+strafe", IN_StrafeDown, "activate strafing mode (move instead of turn)");
    Cmd_AddCommand(CF_CLIENT, "-strafe", IN_StrafeUp, "deactivate strafing mode");
    Cmd_AddCommand(CF_CLIENT, "+moveleft", IN_MoveleftDown, "strafe left");
    Cmd_AddCommand(CF_CLIENT, "-moveleft", IN_MoveleftUp, "stop strafing left");
    Cmd_AddCommand(CF_CLIENT, "+moveright", IN_MoverightDown, "strafe right");
    Cmd_AddCommand(CF_CLIENT, "-moveright", IN_MoverightUp, "stop strafing right");
    Cmd_AddCommand(CF_CLIENT, "+speed", IN_SpeedDown, "activate run mode (faster movement and turning)");
    Cmd_AddCommand(CF_CLIENT, "-speed", IN_SpeedUp, "deactivate run mode");
    Cmd_AddCommand(CF_CLIENT, "+attack", IN_AttackDown, "begin firing");
    Cmd_AddCommand(CF_CLIENT, "-attack", IN_AttackUp, "stop firing");
    Cmd_AddCommand(CF_CLIENT, "+jump", IN_JumpDown, "jump");
    Cmd_AddCommand(CF_CLIENT, "-jump", IN_JumpUp, "end jump (so you can jump again)");
    Cmd_AddCommand(CF_CLIENT, "impulse", IN_Impulse, "send an impulse number to server (select weapon, use item, etc)");
    Cmd_AddCommand(CF_CLIENT, "+klook", IN_KLookDown, "activate keyboard looking mode, do not recenter view");
    Cmd_AddCommand(CF_CLIENT, "-klook", IN_KLookUp, "deactivate keyboard looking mode");
    Cmd_AddCommand(CF_CLIENT, "+mlook", IN_MLookDown, "activate mouse looking mode, do not recenter view");
    Cmd_AddCommand(CF_CLIENT, "-mlook", IN_MLookUp, "deactivate mouse looking mode");
 
    // LadyHavoc: added lots of buttons
    Cmd_AddCommand(CF_CLIENT, "+use", IN_UseDown, "use something (may be used by some mods)");
    Cmd_AddCommand(CF_CLIENT, "-use", IN_UseUp, "stop using something");
    Cmd_AddCommand(CF_CLIENT, "+button3", IN_Button3Down, "activate button3 (behavior depends on mod)");
    Cmd_AddCommand(CF_CLIENT, "-button3", IN_Button3Up, "deactivate button3");
    Cmd_AddCommand(CF_CLIENT, "+button4", IN_Button4Down, "activate button4 (behavior depends on mod)");
    Cmd_AddCommand(CF_CLIENT, "-button4", IN_Button4Up, "deactivate button4");
    Cmd_AddCommand(CF_CLIENT, "+button5", IN_Button5Down, "activate button5 (behavior depends on mod)");
    Cmd_AddCommand(CF_CLIENT, "-button5", IN_Button5Up, "deactivate button5");
    Cmd_AddCommand(CF_CLIENT, "+button6", IN_Button6Down, "activate button6 (behavior depends on mod)");
    Cmd_AddCommand(CF_CLIENT, "-button6", IN_Button6Up, "deactivate button6");
    Cmd_AddCommand(CF_CLIENT, "+button7", IN_Button7Down, "activate button7 (behavior depends on mod)");
    Cmd_AddCommand(CF_CLIENT, "-button7", IN_Button7Up, "deactivate button7");
    Cmd_AddCommand(CF_CLIENT, "+button8", IN_Button8Down, "activate button8 (behavior depends on mod)");
    Cmd_AddCommand(CF_CLIENT, "-button8", IN_Button8Up, "deactivate button8");
    Cmd_AddCommand(CF_CLIENT, "+button9", IN_Button9Down, "activate button9 (behavior depends on mod)");
    Cmd_AddCommand(CF_CLIENT, "-button9", IN_Button9Up, "deactivate button9");
    Cmd_AddCommand(CF_CLIENT, "+button10", IN_Button10Down, "activate button10 (behavior depends on mod)");
    Cmd_AddCommand(CF_CLIENT, "-button10", IN_Button10Up, "deactivate button10");
    Cmd_AddCommand(CF_CLIENT, "+button11", IN_Button11Down, "activate button11 (behavior depends on mod)");
    Cmd_AddCommand(CF_CLIENT, "-button11", IN_Button11Up, "deactivate button11");
    Cmd_AddCommand(CF_CLIENT, "+button12", IN_Button12Down, "activate button12 (behavior depends on mod)");
    Cmd_AddCommand(CF_CLIENT, "-button12", IN_Button12Up, "deactivate button12");
    Cmd_AddCommand(CF_CLIENT, "+button13", IN_Button13Down, "activate button13 (behavior depends on mod)");
    Cmd_AddCommand(CF_CLIENT, "-button13", IN_Button13Up, "deactivate button13");
    Cmd_AddCommand(CF_CLIENT, "+button14", IN_Button14Down, "activate button14 (behavior depends on mod)");
    Cmd_AddCommand(CF_CLIENT, "-button14", IN_Button14Up, "deactivate button14");
    Cmd_AddCommand(CF_CLIENT, "+button15", IN_Button15Down, "activate button15 (behavior depends on mod)");
    Cmd_AddCommand(CF_CLIENT, "-button15", IN_Button15Up, "deactivate button15");
    Cmd_AddCommand(CF_CLIENT, "+button16", IN_Button16Down, "activate button16 (behavior depends on mod)");
    Cmd_AddCommand(CF_CLIENT, "-button16", IN_Button16Up, "deactivate button16");
 
    // LadyHavoc: added bestweapon command
    Cmd_AddCommand(CF_CLIENT, "bestweapon", IN_BestWeapon_f, "send an impulse number to server to select the first usable weapon out of several (example: 8 7 6 5 4 3 2 1)");
    Cmd_AddCommand(CF_CLIENT, "register_bestweapon", IN_BestWeapon_Register_f, "(for QC usage only) change weapon parameters to be used by bestweapon; stuffcmd this in ClientConnect");
 
    Cvar_RegisterVariable(&cl_movecliptokeyboard);
    Cvar_RegisterVariable(&cl_movement);
    Cvar_RegisterVariable(&cl_movement_replay);
    Cvar_RegisterVariable(&cl_movement_nettimeout);
    Cvar_RegisterVariable(&cl_movement_minping);
    Cvar_RegisterVariable(&cl_movement_track_canjump);
    Cvar_RegisterVariable(&cl_movement_maxspeed);
    Cvar_RegisterVariable(&cl_movement_maxairspeed);
    Cvar_RegisterVariable(&cl_movement_stopspeed);
    Cvar_RegisterVariable(&cl_movement_friction);
    Cvar_RegisterVariable(&cl_movement_wallfriction);
    Cvar_RegisterVariable(&cl_movement_waterfriction);
    Cvar_RegisterVariable(&cl_movement_edgefriction);
    Cvar_RegisterVariable(&cl_movement_stepheight);
    Cvar_RegisterVariable(&cl_movement_accelerate);
    Cvar_RegisterVariable(&cl_movement_airaccelerate);
    Cvar_RegisterVariable(&cl_movement_wateraccelerate);
    Cvar_RegisterVariable(&cl_movement_jumpvelocity);
    Cvar_RegisterVariable(&cl_movement_airaccel_qw);
    Cvar_RegisterVariable(&cl_movement_airaccel_sideways_friction);
    Cvar_RegisterVariable(&cl_nopred);
 
    Cvar_RegisterVariable(&in_pitch_min);
    Cvar_RegisterVariable(&in_pitch_max);
    Cvar_RegisterVariable(&m_filter);
    Cvar_RegisterVariable(&m_accelerate);
    Cvar_RegisterVariable(&m_accelerate_minspeed);
    Cvar_RegisterVariable(&m_accelerate_maxspeed);
    Cvar_RegisterVariable(&m_accelerate_filter);
    Cvar_RegisterVariable(&m_accelerate_power);
    Cvar_RegisterVariable(&m_accelerate_power_offset);
    Cvar_RegisterVariable(&m_accelerate_power_senscap);
    Cvar_RegisterVariable(&m_accelerate_power_strength);
    Cvar_RegisterVariable(&m_accelerate_natural_offset);
    Cvar_RegisterVariable(&m_accelerate_natural_accelsenscap);
    Cvar_RegisterVariable(&m_accelerate_natural_strength);
 
    Cvar_RegisterVariable(&cl_netfps);
    Cvar_RegisterVariable(&cl_netrepeatinput);
    Cvar_RegisterVariable(&cl_netimmediatebuttons);
 
    Cvar_RegisterVariable(&cl_nodelta);
 
    Cvar_RegisterVariable(&cl_csqc_generatemousemoveevents);
}

References CF_CLIENT, cl_csqc_generatemousemoveevents, cl_movecliptokeyboard, cl_movement, cl_movement_accelerate, cl_movement_airaccel_qw, cl_movement_airaccel_sideways_friction, cl_movement_airaccelerate, cl_movement_edgefriction, cl_movement_friction, cl_movement_jumpvelocity, cl_movement_maxairspeed, cl_movement_maxspeed, cl_movement_minping, cl_movement_nettimeout, cl_movement_replay, cl_movement_stepheight, cl_movement_stopspeed, cl_movement_track_canjump, cl_movement_wallfriction, cl_movement_wateraccelerate, cl_movement_waterfriction, cl_netfps, cl_netimmediatebuttons, cl_netrepeatinput, cl_nodelta, cl_nopred, Cmd_AddCommand(), Cvar_RegisterVariable(), IN_AttackDown(), IN_AttackUp(), IN_BackDown(), IN_BackUp(), IN_BestWeapon_f(), IN_BestWeapon_Register_f(), IN_Button10Down(), IN_Button10Up(), IN_Button11Down(), IN_Button11Up(), IN_Button12Down(), IN_Button12Up(), IN_Button13Down(), IN_Button13Up(), IN_Button14Down(), IN_Button14Up(), IN_Button15Down(), IN_Button15Up(), IN_Button16Down(), IN_Button16Up(), IN_Button3Down(), IN_Button3Up(), IN_Button4Down(), IN_Button4Up(), IN_Button5Down(), IN_Button5Up(), IN_Button6Down(), IN_Button6Up(), IN_Button7Down(), IN_Button7Up(), IN_Button8Down(), IN_Button8Up(), IN_Button9Down(), IN_Button9Up(), IN_DownDown(), IN_DownUp(), IN_ForwardDown(), IN_ForwardUp(), IN_Impulse(), IN_JumpDown(), IN_JumpUp(), IN_KLookDown(), IN_KLookUp(), IN_LeftDown(), IN_LeftUp(), IN_LookdownDown(), IN_LookdownUp(), IN_LookupDown(), IN_LookupUp(), IN_MLookDown(), IN_MLookUp(), IN_MoveleftDown(), IN_MoveleftUp(), IN_MoverightDown(), IN_MoverightUp(), in_pitch_max, in_pitch_min, IN_RightDown(), IN_RightUp(), IN_SpeedDown(), IN_SpeedUp(), IN_StrafeDown(), IN_StrafeUp(), IN_UpDown(), IN_UpUp(), IN_UseDown(), IN_UseUp(), m_accelerate, m_accelerate_filter, m_accelerate_maxspeed, m_accelerate_minspeed, m_accelerate_natural_accelsenscap, m_accelerate_natural_offset, m_accelerate_natural_strength, m_accelerate_power, m_accelerate_power_offset, m_accelerate_power_senscap, m_accelerate_power_strength, and m_filter.

Referenced by CL_Init().

◆ CL_Input()

void CL_Input ( void )

Definition at line 483 of file cl_input.c.

{
    float mx, my;
    static float old_mouse_x = 0, old_mouse_y = 0;
 
    // clamp before the move to prevent starting with bad angles
    CL_AdjustAngles ();
 
    if(v_flipped.integer)
        cl.viewangles[YAW] = -cl.viewangles[YAW];
 
    // reset some of the command fields
    cl.cmd.forwardmove = 0;
    cl.cmd.sidemove = 0;
    cl.cmd.upmove = 0;
 
    // get basic movement from keyboard
    if (in_strafe.state & 1)
    {
        cl.cmd.sidemove += cl_sidespeed.value * CL_KeyState (&in_right);
        cl.cmd.sidemove -= cl_sidespeed.value * CL_KeyState (&in_left);
    }
 
    cl.cmd.sidemove += cl_sidespeed.value * CL_KeyState (&in_moveright);
    cl.cmd.sidemove -= cl_sidespeed.value * CL_KeyState (&in_moveleft);
 
    cl.cmd.upmove += cl_upspeed.value * CL_KeyState (&in_up);
    cl.cmd.upmove -= cl_upspeed.value * CL_KeyState (&in_down);
 
    if (! (in_klook.state & 1) )
    {
        cl.cmd.forwardmove += cl_forwardspeed.value * CL_KeyState (&in_forward);
        cl.cmd.forwardmove -= cl_backspeed.value * CL_KeyState (&in_back);
    }
 
    // adjust for speed key
    if (in_speed.state & 1)
    {
        cl.cmd.forwardmove *= cl_movespeedkey.value;
        cl.cmd.sidemove *= cl_movespeedkey.value;
        cl.cmd.upmove *= cl_movespeedkey.value;
    }
 
    // allow mice or other external controllers to add to the move
    IN_Move ();
 
    // send mouse move to csqc
    if (CLVM_prog->loaded && cl_csqc_generatemousemoveevents.integer)
    {
        if (cl.csqc_wantsmousemove)
        {
            // event type 3 is a DP_CSQC thing
            static int oldwindowmouse[2];
            if (oldwindowmouse[0] != in_windowmouse_x || oldwindowmouse[1] != in_windowmouse_y)
            {
                CL_VM_InputEvent(3, in_windowmouse_x * vid_conwidth.value / vid.mode.width, in_windowmouse_y * vid_conheight.value / vid.mode.height);
                oldwindowmouse[0] = in_windowmouse_x;
                oldwindowmouse[1] = in_windowmouse_y;
            }
        }
        else
        {
            if (in_mouse_x || in_mouse_y)
                CL_VM_InputEvent(2, in_mouse_x, in_mouse_y);
        }
    }
 
    // apply m_accelerate if it is on
    if(m_accelerate.value > 0)
    {
        float mouse_deltadist = sqrtf(in_mouse_x * in_mouse_x + in_mouse_y * in_mouse_y);
        float speed = mouse_deltadist / cl.realframetime;
        static float averagespeed = 0;
        float f, mi, ma;
        if(m_accelerate_filter.value > 0)
            f = bound(0, cl.realframetime / m_accelerate_filter.value, 1);
        else
            f = 1;
        averagespeed = speed * f + averagespeed * (1 - f);
 
        // Note: this check is technically unnecessary, as everything in here cancels out if it is zero.
        if (m_accelerate.value != 1.0f)
        {
            // First do linear slope acceleration which was ripped "in
            // spirit" from many classic mouse driver implementations.
            // If m_accelerate.value == 1, this code does nothing at all.
 
            mi = max(1, m_accelerate_minspeed.value);
            ma = max(m_accelerate_minspeed.value + 1, m_accelerate_maxspeed.value);
 
            if(averagespeed <= mi)
            {
                f = 1;
            }
            else if(averagespeed >= ma)
            {
                f = m_accelerate.value;
            }
            else
            {
                f = averagespeed;
                f = (f - mi) / (ma - mi) * (m_accelerate.value - 1) + 1;
            }
            in_mouse_x *= f;
            in_mouse_y *= f;
        }
 
        // Note: this check is technically unnecessary, as everything in here cancels out if it is zero.
        if (m_accelerate_power_strength.value != 0.0f)
        {
            // Then do Quake Live-style power acceleration.
            // Note that this behavior REPLACES the usual
            // sensitivity, so we apply it but then divide by
            // sensitivity.value so that the later multiplication
            // restores it again.
            float accelsens = 1.0f;
            float adjusted_speed_pxms = (averagespeed * 0.001f - m_accelerate_power_offset.value) * m_accelerate_power_strength.value;
            float inv_sensitivity = 1.0f / sensitivity.value;
            if (adjusted_speed_pxms > 0)
            {
                if (m_accelerate_power.value > 1.0f)
                {
                    // TODO: How does this interact with sensitivity changes? Is this intended?
                    // Currently: more sensitivity = less acceleration at same pixel speed.
                    accelsens += expf((m_accelerate_power.value - 1.0f) * logf(adjusted_speed_pxms)) * inv_sensitivity;
                }
                else
                {
                    // The limit of the then-branch for m_accelerate_power -> 1.
                    accelsens += inv_sensitivity;
                    // Note: QL had just accelsens = 1.0f.
                    // This is mathematically wrong though.
                }
            }
            else
            {
                // The limit of the then-branch for adjusted_speed -> 0.
                // accelsens += 0.0f;
            }
            if (m_accelerate_power_senscap.value > 0.0f && accelsens > m_accelerate_power_senscap.value * inv_sensitivity)
            {
                // TODO: How does this interact with sensitivity changes? Is this intended?
                // Currently: senscap is in absolute sensitivity units, so if senscap < sensitivity, it overrides.
                accelsens = m_accelerate_power_senscap.value * inv_sensitivity;
            }
 
            in_mouse_x *= accelsens;
            in_mouse_y *= accelsens;
        }
 
        if (m_accelerate_natural_strength.value > 0.0f && m_accelerate_natural_accelsenscap.value >= 0.0f)
        {
            float accelsens = 1.0f;
            float adjusted_speed_pxms = (averagespeed * 0.001f - m_accelerate_natural_offset.value);
 
            if (adjusted_speed_pxms > 0 && m_accelerate_natural_accelsenscap.value != 1.0f)
            {
                float adjusted_accelsenscap = m_accelerate_natural_accelsenscap.value - 1.0f;
                // This equation is made to multiply the sensitivity for a factor between 1 and m_accelerate_natural_accelsenscap
                // this means there is no need to divide it for the sensitivity.value as the whole
                // expression needs to be multiplied by the sensitivity at the end instead of only having the sens multiplied
                accelsens += (adjusted_accelsenscap - adjusted_accelsenscap * exp( - ((adjusted_speed_pxms * m_accelerate_natural_strength.value) / fabs(adjusted_accelsenscap) )));
            }
 
            in_mouse_x *= accelsens;
            in_mouse_y *= accelsens;
        }
    }
 
    // apply m_filter if it is on
    mx = in_mouse_x;
    my = in_mouse_y;
    if (m_filter.integer)
    {
        in_mouse_x = (mx + old_mouse_x) * 0.5;
        in_mouse_y = (my + old_mouse_y) * 0.5;
    }
    old_mouse_x = mx;
    old_mouse_y = my;
 
    // ignore a mouse move if mouse was activated/deactivated this frame
    if (cl_ignoremousemoves)
    {
        cl_ignoremousemoves--;
        in_mouse_x = old_mouse_x = 0;
        in_mouse_y = old_mouse_y = 0;
    }
 
    // if not in menu, apply mouse move to viewangles/movement
    if (!key_consoleactive && key_dest == key_game && !cl.csqc_wantsmousemove && cl_prydoncursor.integer <= 0)
    {
        float modulatedsensitivity = sensitivity.value * cl.sensitivityscale;
        if (in_strafe.state & 1)
        {
            // strafing mode, all looking is movement
            V_StopPitchDrift();
            cl.cmd.sidemove += m_side.value * in_mouse_x * modulatedsensitivity;
            if (noclip_anglehack)
                cl.cmd.upmove -= m_forward.value * in_mouse_y * modulatedsensitivity;
            else
                cl.cmd.forwardmove -= m_forward.value * in_mouse_y * modulatedsensitivity;
        }
        else if ((in_mlook.state & 1) || freelook.integer)
        {
            // mouselook, lookstrafe causes turning to become strafing
            V_StopPitchDrift();
            if (lookstrafe.integer)
                cl.cmd.sidemove += m_side.value * in_mouse_x * modulatedsensitivity;
            else
                cl.viewangles[YAW] -= m_yaw.value * in_mouse_x * modulatedsensitivity * cl.viewzoom;
            cl.viewangles[PITCH] += m_pitch.value * in_mouse_y * modulatedsensitivity * cl.viewzoom;
        }
        else
        {
            // non-mouselook, yaw turning and forward/back movement
            cl.viewangles[YAW] -= m_yaw.value * in_mouse_x * modulatedsensitivity * cl.viewzoom;
            cl.cmd.forwardmove -= m_forward.value * in_mouse_y * modulatedsensitivity;
        }
    }
    else // don't pitch drift when csqc is controlling the mouse
    {
        // mouse interacting with the scene, mostly stationary view
        V_StopPitchDrift();
        // update prydon cursor
        cl.cmd.cursor_screen[0] = in_windowmouse_x * 2.0 / vid.mode.width - 1.0;
        cl.cmd.cursor_screen[1] = in_windowmouse_y * 2.0 / vid.mode.height - 1.0;
    }
 
    if(v_flipped.integer)
    {
        cl.viewangles[YAW] = -cl.viewangles[YAW];
        cl.cmd.sidemove = -cl.cmd.sidemove;
    }
 
    // clamp after the move to prevent rendering with bad angles
    CL_AdjustAngles ();
 
    if(cl_movecliptokeyboard.integer)
    {
        vec_t f = 1;
        if (in_speed.state & 1)
            f *= cl_movespeedkey.value;
        if(cl_movecliptokeyboard.integer == 2)
        {
            // digital direction, analog amount
            vec_t wishvel_x, wishvel_y;
            wishvel_x = fabs(cl.cmd.forwardmove);
            wishvel_y = fabs(cl.cmd.sidemove);
            if(wishvel_x != 0 && wishvel_y != 0 && wishvel_x != wishvel_y)
            {
                vec_t wishspeed = sqrt(wishvel_x * wishvel_x + wishvel_y * wishvel_y);
                if(wishvel_x >= 2 * wishvel_y)
                {
                    // pure X motion
                    if(cl.cmd.forwardmove > 0)
                        cl.cmd.forwardmove = wishspeed;
                    else
                        cl.cmd.forwardmove = -wishspeed;
                    cl.cmd.sidemove = 0;
                }
                else if(wishvel_y >= 2 * wishvel_x)
                {
                    // pure Y motion
                    cl.cmd.forwardmove = 0;
                    if(cl.cmd.sidemove > 0)
                        cl.cmd.sidemove = wishspeed;
                    else
                        cl.cmd.sidemove = -wishspeed;
                }
                else
                {
                    // diagonal
                    if(cl.cmd.forwardmove > 0)
                        cl.cmd.forwardmove = 0.70710678118654752440 * wishspeed;
                    else
                        cl.cmd.forwardmove = -0.70710678118654752440 * wishspeed;
                    if(cl.cmd.sidemove > 0)
                        cl.cmd.sidemove = 0.70710678118654752440 * wishspeed;
                    else
                        cl.cmd.sidemove = -0.70710678118654752440 * wishspeed;
                }
            }
        }
        else if(cl_movecliptokeyboard.integer)
        {
            // digital direction, digital amount
            if(cl.cmd.sidemove >= cl_sidespeed.value * f * 0.5)
                cl.cmd.sidemove = cl_sidespeed.value * f;
            else if(cl.cmd.sidemove <= -cl_sidespeed.value * f * 0.5)
                cl.cmd.sidemove = -cl_sidespeed.value * f;
            else
                cl.cmd.sidemove = 0;
            if(cl.cmd.forwardmove >= cl_forwardspeed.value * f * 0.5)
                cl.cmd.forwardmove = cl_forwardspeed.value * f;
            else if(cl.cmd.forwardmove <= -cl_backspeed.value * f * 0.5)
                cl.cmd.forwardmove = -cl_backspeed.value * f;
            else
                cl.cmd.forwardmove = 0;
        }
    }
}

References bound, cl, CL_AdjustAngles(), cl_backspeed, cl_csqc_generatemousemoveevents, cl_forwardspeed, cl_ignoremousemoves, CL_KeyState(), cl_movecliptokeyboard, cl_movespeedkey, cl_prydoncursor, cl_sidespeed, cl_upspeed, CL_VM_InputEvent(), CLVM_prog, client_state_t::cmd, client_state_t::csqc_wantsmousemove, usercmd_t::cursor_screen, f, fabs(), usercmd_t::forwardmove, freelook, viddef_mode_t::height, in_back, in_down, in_forward, in_klook, in_left, in_mlook, in_mouse_x, in_mouse_y, IN_Move(), in_moveleft, in_moveright, in_right, in_speed, in_strafe, in_up, in_windowmouse_x, in_windowmouse_y, cvar_t::integer, key_consoleactive, key_dest, key_game, lookstrafe, m_accelerate, m_accelerate_filter, m_accelerate_maxspeed, m_accelerate_minspeed, m_accelerate_natural_accelsenscap, m_accelerate_natural_offset, m_accelerate_natural_strength, m_accelerate_power, m_accelerate_power_offset, m_accelerate_power_senscap, m_accelerate_power_strength, m_filter, m_forward, m_pitch, m_side, m_yaw, max, viddef_t::mode, noclip_anglehack, PITCH, client_state_t::realframetime, sensitivity, client_state_t::sensitivityscale, usercmd_t::sidemove, sqrt(), kbutton_t::state, usercmd_t::upmove, v_flipped, V_StopPitchDrift(), cvar_t::value, vid, vid_conheight, vid_conwidth, client_state_t::viewangles, client_state_t::viewzoom, viddef_mode_t::width, wishspeed, and YAW.

Referenced by CL_Frame().

◆ CL_KeyState()

float CL_KeyState ( kbutton_t * key )

Definition at line 315 of file cl_input.c.

{
    float       val;
    qbool   impulsedown, impulseup, down;
 
    impulsedown = (key->state & 2) != 0;
    impulseup = (key->state & 4) != 0;
    down = (key->state & 1) != 0;
    val = 0;
 
    if (impulsedown && !impulseup)
    {
        if (down)
            val = 0.5;  // pressed and held this frame
        else
            val = 0;    //  I_Error ();
    }
    if (impulseup && !impulsedown)
    {
        if (down)
            val = 0;    //  I_Error ();
        else
            val = 0;    // released this frame
    }
    if (!impulsedown && !impulseup)
    {
        if (down)
            val = 1.0;  // held the entire frame
        else
            val = 0;    // up the entire frame
    }
    if (impulsedown && impulseup)
    {
        if (down)
            val = 0.75; // released and re-pressed this frame
        else
            val = 0.25; // pressed and released this frame
    }
 
    key->state &= 1;        // clear impulses
 
    return val;
}

References kbutton_t::state.

Referenced by CL_AdjustAngles(), and CL_Input().

◆ CL_LerpUpdate()

void CL_LerpUpdate ( entity_t * e )

◆ CL_Locs_FindLocationName()

void CL_Locs_FindLocationName	(	char *	buffer,
		size_t	buffersize,
		vec3_t	point )

Definition at line 2218 of file cl_main.c.

{
    cl_locnode_t *loc;
    loc = CL_Locs_FindNearest(point);
    if (loc)
        dp_strlcpy(buffer, loc->name, buffersize);
    else
        dpsnprintf(buffer, buffersize, "LOC=%.0f:%.0f:%.0f", point[0], point[1], point[2]);
}

References buffer, CL_Locs_FindNearest(), dp_strlcpy, dpsnprintf(), and cl_locnode_t::name.

Referenced by CL_ForwardToServer().

◆ CL_Locs_FindNearest()

cl_locnode_t * CL_Locs_FindNearest ( const vec3_t point )

Definition at line 2193 of file cl_main.c.

{
    int i;
    cl_locnode_t *loc;
    cl_locnode_t *best;
    vec3_t nearestpoint;
    vec_t dist, bestdist;
    best = NULL;
    bestdist = 0;
    for (loc = cl.locnodes;loc;loc = loc->next)
    {
        for (i = 0;i < 3;i++)
            nearestpoint[i] = bound(loc->mins[i], point[i], loc->maxs[i]);
        dist = VectorDistance2(nearestpoint, point);
        if (bestdist > dist || !best)
        {
            bestdist = dist;
            best = loc;
            if (bestdist < 1)
                break;
        }
    }
    return best;
}

References bound, cl, i, client_state_t::locnodes, cl_locnode_t::maxs, cl_locnode_t::mins, cl_locnode_t::next, NULL, and VectorDistance2.

Referenced by CL_Locs_FindLocationName(), CL_Locs_RemoveNearest_f(), R_DrawLocs(), and R_TimeReport_EndFrame().

◆ CL_Locs_Reload_f()

void CL_Locs_Reload_f ( cmd_state_t * cmd )

Definition at line 2377 of file cl_main.c.

{
    int i, linenumber, limit, len;
    const char *s;
    char *filedata, *text, *textend, *linestart, *linetext, *lineend;
    fs_offset_t filesize;
    vec3_t mins, maxs;
    char locfilename[MAX_QPATH];
    char name[MAX_INPUTLINE];
 
    if (cls.state != ca_connected || !cl.worldmodel)
    {
        Con_Printf("No level loaded!\n");
        return;
    }
 
    CL_Locs_Clear_f(cmd);
 
    // try maps/something.loc first (LadyHavoc: where I think they should be)
    dpsnprintf(locfilename, sizeof(locfilename), "%s.loc", cl.worldnamenoextension);
    filedata = (char *)FS_LoadFile(locfilename, cls.levelmempool, false, &filesize);
    if (!filedata)
    {
        // try proquake name as well (LadyHavoc: I hate path mangling)
        dpsnprintf(locfilename, sizeof(locfilename), "locs/%s.loc", cl.worldbasename);
        filedata = (char *)FS_LoadFile(locfilename, cls.levelmempool, false, &filesize);
        if (!filedata)
            return;
    }
    text = filedata;
    textend = filedata + filesize;
    for (linenumber = 1;text < textend;linenumber++)
    {
        linestart = text;
        for (;text < textend && *text != '\r' && *text != '\n';text++)
            ;
        lineend = text;
        if (text + 1 < textend && *text == '\r' && text[1] == '\n')
            text++;
        if (text < textend)
            text++;
        // trim trailing whitespace
        while (lineend > linestart && ISWHITESPACE(lineend[-1]))
            lineend--;
        // trim leading whitespace
        while (linestart < lineend && ISWHITESPACE(*linestart))
            linestart++;
        // check if this is a comment
        if (linestart + 2 <= lineend && !strncmp(linestart, "//", 2))
            continue;
        linetext = linestart;
        limit = 3;
        for (i = 0;i < limit;i++)
        {
            if (linetext >= lineend)
                break;
            // note: a missing number is interpreted as 0
            if (i < 3)
                mins[i] = atof(linetext);
            else
                maxs[i - 3] = atof(linetext);
            // now advance past the number
            while (linetext < lineend && !ISWHITESPACE(*linetext) && *linetext != ',')
                linetext++;
            // advance through whitespace
            if (linetext < lineend)
            {
                if (*linetext == ',')
                {
                    linetext++;
                    limit = 6;
                    // note: comma can be followed by whitespace
                }
                if (ISWHITESPACE(*linetext))
                {
                    // skip whitespace
                    while (linetext < lineend && ISWHITESPACE(*linetext))
                        linetext++;
                }
            }
        }
        // if this is a quoted name, remove the quotes
        if (i == 6)
        {
            if (linetext >= lineend || *linetext != '"')
                continue; // proquake location names are always quoted
            lineend--;
            linetext++;
            len = min(lineend - linetext, (int)sizeof(name) - 1);
            memcpy(name, linetext, len);
            name[len] = 0;
            // add the box to the list
            CL_Locs_AddNode(mins, maxs, name);
        }
        // if a point was parsed, it needs to be scaled down by 8 (since
        // point-based loc files were invented by a proxy which dealt
        // directly with quake protocol coordinates, which are *8), turn
        // it into a box
        else if (i == 3)
        {
            // interpret silly fuhquake macros
            for (len = 0;len < (int)sizeof(name) - 1 && linetext < lineend;)
            {
                if (*linetext == '$')
                {
                    if (linetext + 18 <= lineend && !strncmp(linetext, "$loc_name_separator", 19)) {s = " ";linetext += 19;}
                    else if (linetext + 13 <= lineend && !strncmp(linetext, "$loc_name_ssg", 13)) {s = "SSG";linetext += 13;}
                    else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_ng", 12)) {s = "NG";linetext += 12;}
                    else if (linetext + 13 <= lineend && !strncmp(linetext, "$loc_name_sng", 13)) {s = "SNG";linetext += 13;}
                    else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_gl", 12)) {s = "GL";linetext += 12;}
                    else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_rl", 12)) {s = "RL";linetext += 12;}
                    else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_lg", 12)) {s = "LG";linetext += 12;}
                    else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_ga", 12)) {s = "GA";linetext += 12;}
                    else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_ya", 12)) {s = "YA";linetext += 12;}
                    else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_ra", 12)) {s = "RA";linetext += 12;}
                    else if (linetext + 12 <= lineend && !strncmp(linetext, "$loc_name_mh", 12)) {s = "MEGA";linetext += 12;}
                    else s = NULL;
                    if (s)
                    {
                        while (len < (int)sizeof(name) - 1 && *s)
                            name[len++] = *s++;
                        continue;
                    }
                }
                name[len++] = *linetext++;
            }
            name[len] = 0;
            // add the point to the list
            VectorScale(mins, (1.0 / 8.0), mins);
            CL_Locs_AddNode(mins, mins, name);
        }
        else
            continue;
    }
}

References ca_connected, cl, CL_Locs_AddNode(), CL_Locs_Clear_f(), cls, cmd(), Con_Printf(), dpsnprintf(), FS_LoadFile(), i, int(), ISWHITESPACE, client_static_t::levelmempool, MAX_INPUTLINE, MAX_QPATH, maxs, min, mins, name, NULL, client_static_t::state, VectorScale, client_state_t::worldbasename, client_state_t::worldmodel, and client_state_t::worldnamenoextension.

Referenced by CL_Init(), and CL_SetupWorldModel().

◆ CL_MeshEntities_Init()

void CL_MeshEntities_Init ( void )

Definition at line 2555 of file cl_main.c.

{
    int i;
    entity_t *ent;
    for (i = 0; i < NUM_MESHENTITIES; i++)
    {
        ent = cl_meshentities + i;
        ent->state_current.active = true;
        ent->render.model = cl_meshentitymodels + i;
        Mod_Mesh_Create(ent->render.model, cl_meshentitynames[i]);  
        ent->render.alpha = 1;
        ent->render.flags = RENDER_SHADOW | RENDER_LIGHT;
        ent->render.framegroupblend[0].lerp = 1;
        ent->render.frameblend[0].lerp = 1;
        VectorSet(ent->render.colormod, 1, 1, 1);
        VectorSet(ent->render.glowmod, 1, 1, 1);
        VectorSet(ent->render.custommodellight_ambient, 1, 1, 1);
        VectorSet(ent->render.custommodellight_diffuse, 0, 0, 0);
        VectorSet(ent->render.custommodellight_lightdir, 0, 0, 1);
        VectorSet(ent->render.render_fullbright, 1, 1, 1);
        VectorSet(ent->render.render_glowmod, 0, 0, 0);
        VectorSet(ent->render.render_modellight_ambient, 1, 1, 1);
        VectorSet(ent->render.render_modellight_diffuse, 0, 0, 0);
        VectorSet(ent->render.render_modellight_specular, 0, 0, 0);
        VectorSet(ent->render.render_modellight_lightdir_world, 0, 0, 1);
        VectorSet(ent->render.render_modellight_lightdir_local, 0, 0, 1); // local doesn't matter because no diffuse/specular color
        VectorSet(ent->render.render_lightmap_ambient, 0, 0, 0);
        VectorSet(ent->render.render_lightmap_diffuse, 1, 1, 1);
        VectorSet(ent->render.render_lightmap_specular, 1, 1, 1);
        VectorSet(ent->render.render_rtlight_diffuse, 1, 1, 1);
        VectorSet(ent->render.render_rtlight_specular, 1, 1, 1);
 
        Matrix4x4_CreateIdentity(&ent->render.matrix);
        CL_UpdateRenderEntity(&ent->render);
    }
    cl_meshentities[MESH_UI].render.flags = RENDER_NOSELFSHADOW;
    R_RegisterModule("CL_MeshEntities", CL_MeshEntities_Start, CL_MeshEntities_Shutdown, CL_MeshEntities_Restart, CL_MeshEntities_Restart, CL_MeshEntities_Restart);
}

Referenced by Render_Init().

◆ CL_MeshEntities_Scene_AddRenderEntity()

void CL_MeshEntities_Scene_AddRenderEntity ( void )

Definition at line 2599 of file cl_main.c.

{
    entity_t* ent = &cl_meshentities[MESH_SCENE];
    r_refdef.scene.entities[r_refdef.scene.numentities++] = &ent->render;
}

References cl_meshentities, r_refdef_scene_t::entities, MESH_SCENE, r_refdef_scene_t::numentities, r_refdef, entity_t::render, and r_refdef_t::scene.

Referenced by CSQC_RelinkAllEntities().

◆ CL_MeshEntities_Scene_Clear()

void CL_MeshEntities_Scene_Clear ( void )

Definition at line 2594 of file cl_main.c.

{
    Mod_Mesh_Reset(CL_Mesh_Scene());
}

References CL_Mesh_Scene, and Mod_Mesh_Reset().

Referenced by CL_UpdateWorld(), and VM_CL_R_ClearScene().

◆ CL_MeshEntities_Scene_FinalizeRenderEntity()

void CL_MeshEntities_Scene_FinalizeRenderEntity ( void )

Definition at line 2605 of file cl_main.c.

{
    entity_t *ent = &cl_meshentities[MESH_SCENE];
    Mod_Mesh_Finalize(ent->render.model);
    VectorCopy(ent->render.model->normalmins, ent->render.mins);
    VectorCopy(ent->render.model->normalmaxs, ent->render.maxs);
}

References cl_meshentities, entity_render_t::maxs, MESH_SCENE, entity_render_t::mins, Mod_Mesh_Finalize(), entity_render_t::model, model_t::normalmaxs, model_t::normalmins, entity_t::render, and VectorCopy.

Referenced by SCR_DrawScreen(), and VM_CL_R_RenderScene().

◆ CL_MoveLerpEntityStates()

void CL_MoveLerpEntityStates ( entity_t * ent )

Definition at line 1991 of file cl_parse.c.

{
    float odelta[3], adelta[3];
    VectorSubtract(ent->state_current.origin, ent->persistent.neworigin, odelta);
    VectorSubtract(ent->state_current.angles, ent->persistent.newangles, adelta);
    if (!ent->state_previous.active || ent->state_previous.modelindex != ent->state_current.modelindex)
    {
        // reset all persistent stuff if this is a new entity
        ent->persistent.lerpdeltatime = 0;
        ent->persistent.lerpstarttime = cl.mtime[1];
        VectorCopy(ent->state_current.origin, ent->persistent.oldorigin);
        VectorCopy(ent->state_current.angles, ent->persistent.oldangles);
        VectorCopy(ent->state_current.origin, ent->persistent.neworigin);
        VectorCopy(ent->state_current.angles, ent->persistent.newangles);
        // reset animation interpolation as well
        ent->render.framegroupblend[0].frame = ent->render.framegroupblend[1].frame = ent->state_current.frame;
        ent->render.framegroupblend[0].start = ent->render.framegroupblend[1].start = cl.time;
        ent->render.framegroupblend[0].lerp = 1;ent->render.framegroupblend[1].lerp = 0;
        ent->render.shadertime = cl.time;
        // reset various persistent stuff
        ent->persistent.muzzleflash = 0;
        ent->persistent.trail_allowed = false;
    }
    else if ((ent->state_previous.effects & EF_TELEPORT_BIT) != (ent->state_current.effects & EF_TELEPORT_BIT))
    {
        // don't interpolate the move
        ent->persistent.lerpdeltatime = 0;
        ent->persistent.lerpstarttime = cl.mtime[1];
        VectorCopy(ent->state_current.origin, ent->persistent.oldorigin);
        VectorCopy(ent->state_current.angles, ent->persistent.oldangles);
        VectorCopy(ent->state_current.origin, ent->persistent.neworigin);
        VectorCopy(ent->state_current.angles, ent->persistent.newangles);
        ent->persistent.trail_allowed = false;
 
        // if(ent->state_current.frame != ent->state_previous.frame)
        // do this even if we did change the frame
        // teleport bit is only used if an animation restart, or a jump, is necessary
        // so it should be always harmless to do this
        {
            ent->render.framegroupblend[0].frame = ent->render.framegroupblend[1].frame = ent->state_current.frame;
            ent->render.framegroupblend[0].start = ent->render.framegroupblend[1].start = cl.time;
            ent->render.framegroupblend[0].lerp = 1;ent->render.framegroupblend[1].lerp = 0;
        }
 
        // note that this case must do everything the following case does too
    }
    else if ((ent->state_previous.effects & EF_RESTARTANIM_BIT) != (ent->state_current.effects & EF_RESTARTANIM_BIT))
    {
        ent->render.framegroupblend[1] = ent->render.framegroupblend[0];
        ent->render.framegroupblend[1].lerp = 1;
        ent->render.framegroupblend[0].frame = ent->state_current.frame;
        ent->render.framegroupblend[0].start = cl.time;
        ent->render.framegroupblend[0].lerp = 0;
    }
    else if (DotProduct(odelta, odelta) > 1000*1000
        || (cl.fixangle[0] && !cl.fixangle[1])
        || (ent->state_previous.tagindex != ent->state_current.tagindex)
        || (ent->state_previous.tagentity != ent->state_current.tagentity))
    {
        // don't interpolate the move
        // (the fixangle[] check detects teleports, but not constant fixangles
        //  such as when spectating)
        ent->persistent.lerpdeltatime = 0;
        ent->persistent.lerpstarttime = cl.mtime[1];
        VectorCopy(ent->state_current.origin, ent->persistent.oldorigin);
        VectorCopy(ent->state_current.angles, ent->persistent.oldangles);
        VectorCopy(ent->state_current.origin, ent->persistent.neworigin);
        VectorCopy(ent->state_current.angles, ent->persistent.newangles);
        ent->persistent.trail_allowed = false;
    }
    else if (ent->state_current.flags & RENDER_STEP)
    {
        // monster interpolation
        if (DotProduct(odelta, odelta) + DotProduct(adelta, adelta) > 0.01)
        {
            ent->persistent.lerpdeltatime = bound(0, cl.mtime[1] - ent->persistent.lerpstarttime, 0.1);
            ent->persistent.lerpstarttime = cl.mtime[1];
            VectorCopy(ent->persistent.neworigin, ent->persistent.oldorigin);
            VectorCopy(ent->persistent.newangles, ent->persistent.oldangles);
            VectorCopy(ent->state_current.origin, ent->persistent.neworigin);
            VectorCopy(ent->state_current.angles, ent->persistent.newangles);
        }
    }
    else
    {
        // not a monster
        ent->persistent.lerpstarttime = ent->state_previous.time;
        ent->persistent.lerpdeltatime = bound(0, ent->state_current.time - ent->state_previous.time, 0.1);
        VectorCopy(ent->persistent.neworigin, ent->persistent.oldorigin);
        VectorCopy(ent->persistent.newangles, ent->persistent.oldangles);
        VectorCopy(ent->state_current.origin, ent->persistent.neworigin);
        VectorCopy(ent->state_current.angles, ent->persistent.newangles);
    }
    // trigger muzzleflash effect if necessary
    if (ent->state_current.effects & EF_MUZZLEFLASH)
        ent->persistent.muzzleflash = 1;
 
    // restart animation bit
    if ((ent->state_previous.effects & EF_RESTARTANIM_BIT) != (ent->state_current.effects & EF_RESTARTANIM_BIT))
    {
        ent->render.framegroupblend[1] = ent->render.framegroupblend[0];
        ent->render.framegroupblend[1].lerp = 1;
        ent->render.framegroupblend[0].frame = ent->state_current.frame;
        ent->render.framegroupblend[0].start = cl.time;
        ent->render.framegroupblend[0].lerp = 0;
    }
}

Referenced by EntityFrame4_CL_ReadFrame(), EntityFrame5_CL_ReadFrame(), EntityFrame_CL_ReadFrame(), EntityFrameQuake_ReadEntity(), EntityFrameQW_CL_ReadFrame(), and EntityStateQW_ReadPlayerUpdate().

◆ CL_NewBeam()

void CL_NewBeam	(	int	ent,
		vec3_t	start,
		vec3_t	end,
		model_t *	m,
		int	lightning )

Definition at line 2356 of file cl_parse.c.

{
    int i;
    beam_t *b = NULL;
 
    if (ent >= MAX_EDICTS)
    {
        Con_Printf("CL_NewBeam: invalid entity number %i\n", ent);
        ent = 0;
    }
 
    if (ent >= cl.max_entities)
        CL_ExpandEntities(ent);
 
    // override any beam with the same entity
    i = cl.max_beams;
    if (ent)
        for (i = 0, b = cl.beams;i < cl.max_beams;i++, b++)
            if (b->entity == ent)
                break;
    // if the entity was not found then just replace an unused beam
    if (i == cl.max_beams)
        for (i = 0, b = cl.beams;i < cl.max_beams;i++, b++)
            if (!b->model)
                break;
    if (i < cl.max_beams)
    {
        cl.num_beams = max(cl.num_beams, i + 1);
        b->entity = ent;
        b->lightning = lightning;
        b->model = m;
        b->endtime = cl.mtime[0] + 0.2;
        VectorCopy (start, b->start);
        VectorCopy (end, b->end);
    }
    else
        Con_DPrint("beam list overflow!\n");
}

References b, client_state_t::beams, cl, CL_ExpandEntities(), Con_DPrint(), Con_Printf(), i, max, client_state_t::max_beams, MAX_EDICTS, client_state_t::max_entities, client_state_t::mtime, NULL, client_state_t::num_beams, and VectorCopy.

Referenced by CL_ParseBeam(), VM_CL_te_beam(), VM_CL_te_lightning1(), VM_CL_te_lightning2(), and VM_CL_te_lightning3().

◆ CL_NewFrameReceived()

void CL_NewFrameReceived ( int num )

Definition at line 1737 of file cl_input.c.

{
    if (developer_networkentities.integer >= 10)
        Con_Printf("recv: svc_entities %i\n", num);
    cl.latestframenums[cl.latestframenumsposition] = num;
    cl.latestsendnums[cl.latestframenumsposition] = cl.cmd.sequence;
    cl.latestframenumsposition = (cl.latestframenumsposition + 1) % LATESTFRAMENUMS;
}

References cl, client_state_t::cmd, Con_Printf(), developer_networkentities, cvar_t::integer, LATESTFRAMENUMS, client_state_t::latestframenums, client_state_t::latestframenumsposition, client_state_t::latestsendnums, and usercmd_t::sequence.

Referenced by EntityFrame4_CL_ReadFrame(), EntityFrame5_CL_ReadFrame(), and EntityFrame_CL_ReadFrame().

◆ CL_NewTempEntity()

entity_render_t * CL_NewTempEntity ( double shadertime )

Definition at line 794 of file cl_main.c.

{
    entity_render_t *render;
 
    if (r_refdef.scene.numentities >= r_refdef.scene.maxentities)
        return NULL;
    if (r_refdef.scene.numtempentities >= r_refdef.scene.maxtempentities)
    {
        r_refdef.scene.expandtempentities = true; // will be reallocated next frame since current frame may have pointers set already
        return NULL;
    }
    render = &r_refdef.scene.tempentities[r_refdef.scene.numtempentities++];
    memset (render, 0, sizeof(*render));
    r_refdef.scene.entities[r_refdef.scene.numentities++] = render;
 
    render->shadertime = shadertime;
    render->alpha = 1;
    VectorSet(render->colormod, 1, 1, 1);
    VectorSet(render->glowmod, 1, 1, 1);
    return render;
}

References entity_render_t::alpha, entity_render_t::colormod, r_refdef_scene_t::entities, r_refdef_scene_t::expandtempentities, entity_render_t::glowmod, r_refdef_scene_t::maxentities, r_refdef_scene_t::maxtempentities, NULL, r_refdef_scene_t::numentities, r_refdef_scene_t::numtempentities, r_refdef, r_refdef_t::scene, entity_render_t::shadertime, r_refdef_scene_t::tempentities, and VectorSet.

Referenced by CL_AddQWCTFFlagModel(), CL_RelinkBeams(), CL_RelinkEffects(), CL_RelinkQWNails(), and CSQC_AddRenderEdict().

◆ CL_NextDemo()

void CL_NextDemo ( void )

Definition at line 50 of file cl_demo.c.

{
    char    str[MAX_INPUTLINE];
 
    if (cls.demonum == -1)
        return;     // don't play demos
 
    if (!cls.demos[cls.demonum][0] || cls.demonum == MAX_DEMOS)
    {
        cls.demonum = 0;
        if (!cls.demos[cls.demonum][0])
        {
            Con_Print("No demos listed with startdemos\n");
            cls.demonum = -1;
            return;
        }
    }
 
    dpsnprintf (str, sizeof(str), "playdemo %s\n", cls.demos[cls.demonum]);
    Cbuf_InsertText(cmd_local, str);
    cls.demonum++;
}

References Cbuf_InsertText(), cls, cmd_local, Con_Print(), client_static_t::demonum, client_static_t::demos, dpsnprintf(), MAX_DEMOS, and MAX_INPUTLINE.

Referenced by CL_Demos_f(), CL_ParseServerMessage(), and CL_Startdemos_f().

◆ CL_ParseEntityLump()

void CL_ParseEntityLump ( char * entitystring )

Definition at line 384 of file cl_parse.c.

{
    qbool loadedsky = false;
    const char *data;
    char key[128], value[MAX_INPUTLINE];
    FOG_clear(); // LadyHavoc: no fog until set
    // LadyHavoc: default to the map's sky (q3 shader parsing sets this)
    R_SetSkyBox(cl.worldmodel->brush.skybox);
    data = entdata;
    if (!data)
        return;
    if (!COM_ParseToken_Simple(&data, false, false, true))
        return; // error
    if (com_token[0] != '{')
        return; // error
    while (1)
    {
        if (!COM_ParseToken_Simple(&data, false, false, true))
            return; // error
        if (com_token[0] == '}')
            break; // end of worldspawn
        if (com_token[0] == '_')
            dp_strlcpy (key, com_token + 1, sizeof (key));
        else
            dp_strlcpy (key, com_token, sizeof (key));
        while (key[strlen(key)-1] == ' ') // remove trailing spaces
            key[strlen(key)-1] = 0;
        if (!COM_ParseToken_Simple(&data, false, false, true))
            return; // error
        dp_strlcpy (value, com_token, sizeof (value));
        if (!strcmp("sky", key))
        {
            loadedsky = true;
            R_SetSkyBox(value);
        }
        else if (!strcmp("skyname", key)) // non-standard, introduced by QuakeForge... sigh.
        {
            loadedsky = true;
            R_SetSkyBox(value);
        }
        else if (!strcmp("qlsky", key)) // non-standard, introduced by QuakeLives (EEK)
        {
            loadedsky = true;
            R_SetSkyBox(value);
        }
        else if (!strcmp("fog", key))
        {
            FOG_clear(); // so missing values get good defaults
            r_refdef.fog_start = 0;
            r_refdef.fog_alpha = 1;
            r_refdef.fog_end = 16384;
            r_refdef.fog_height = 1<<30;
            r_refdef.fog_fadedepth = 128;
#if _MSC_VER >= 1400
#define sscanf sscanf_s
#endif
            sscanf(value, "%f %f %f %f %f %f %f %f %f", &r_refdef.fog_density, &r_refdef.fog_red, &r_refdef.fog_green, &r_refdef.fog_blue, &r_refdef.fog_alpha, &r_refdef.fog_start, &r_refdef.fog_end, &r_refdef.fog_height, &r_refdef.fog_fadedepth);
        }
        else if (!strcmp("fog_density", key))
            r_refdef.fog_density = atof(value);
        else if (!strcmp("fog_red", key))
            r_refdef.fog_red = atof(value);
        else if (!strcmp("fog_green", key))
            r_refdef.fog_green = atof(value);
        else if (!strcmp("fog_blue", key))
            r_refdef.fog_blue = atof(value);
        else if (!strcmp("fog_alpha", key))
            r_refdef.fog_alpha = atof(value);
        else if (!strcmp("fog_start", key))
            r_refdef.fog_start = atof(value);
        else if (!strcmp("fog_end", key))
            r_refdef.fog_end = atof(value);
        else if (!strcmp("fog_height", key))
            r_refdef.fog_height = atof(value);
        else if (!strcmp("fog_fadedepth", key))
            r_refdef.fog_fadedepth = atof(value);
        else if (!strcmp("fog_heighttexture", key))
        {
            FOG_clear(); // so missing values get good defaults
#if _MSC_VER >= 1400
            sscanf_s(value, "%f %f %f %f %f %f %f %f %f %s", &r_refdef.fog_density, &r_refdef.fog_red, &r_refdef.fog_green, &r_refdef.fog_blue, &r_refdef.fog_alpha, &r_refdef.fog_start, &r_refdef.fog_end, &r_refdef.fog_height, &r_refdef.fog_fadedepth, r_refdef.fog_height_texturename, (unsigned int)sizeof(r_refdef.fog_height_texturename));
#else
            sscanf(value, "%f %f %f %f %f %f %f %f %f %63s", &r_refdef.fog_density, &r_refdef.fog_red, &r_refdef.fog_green, &r_refdef.fog_blue, &r_refdef.fog_alpha, &r_refdef.fog_start, &r_refdef.fog_end, &r_refdef.fog_height, &r_refdef.fog_fadedepth, r_refdef.fog_height_texturename);
#endif
            r_refdef.fog_height_texturename[63] = 0;
        }
    }
 
    if (!loadedsky && cl.worldmodel->brush.isq2bsp)
        R_SetSkyBox("unit1_");
}

References cl, COM_ParseToken_Simple(), com_token, data, dp_strlcpy, r_refdef_t::fog_alpha, r_refdef_t::fog_blue, FOG_clear(), r_refdef_t::fog_density, r_refdef_t::fog_end, r_refdef_t::fog_fadedepth, r_refdef_t::fog_green, r_refdef_t::fog_height, r_refdef_t::fog_height_texturename, r_refdef_t::fog_red, r_refdef_t::fog_start, MAX_INPUTLINE, r_refdef, R_SetSkyBox(), strlen(), value, and client_state_t::worldmodel.

Referenced by gl_main_newmap().

◆ CL_ParseTEnt()

void CL_ParseTEnt ( void )

◆ CL_PasteDemo()

void CL_PasteDemo	(	unsigned char **	buf,
		fs_offset_t *	filesize )

Definition at line 160 of file cl_demo.c.

{
    fs_offset_t startoffset = 0;
 
    if(!*buf)
        return;
 
    // skip cdtrack
    while(startoffset < *filesize && ((char *)(*buf))[startoffset] != '\n')
        ++startoffset;
    if(startoffset < *filesize)
        ++startoffset;
 
    FS_Write(cls.demofile, *buf + startoffset, *filesize - startoffset);
 
    Mem_Free(*buf);
    *buf = NULL;
    *filesize = 0;
}

References buf, cls, client_static_t::demofile, FS_Write(), Mem_Free, and NULL.

Referenced by CL_VM_Init().

◆ CL_PlayDemo()

void CL_PlayDemo ( const char * demo )

Definition at line 413 of file cl_demo.c.

{
    char name[MAX_QPATH];
    int c;
    qbool neg = false;
    qfile_t *f;
 
    // open the demo file
    dp_strlcpy (name, demo, sizeof (name));
    FS_DefaultExtension (name, ".dem", sizeof (name));
    f = FS_OpenVirtualFile(name, false);
    if (!f)
    {
        Con_Printf(CON_ERROR "ERROR: couldn't open %s.\n", name);
        cls.demonum = -1;       // stop demo loop
        return;
    }
 
    cls.demostarting = true;
 
    // disconnect from server
    CL_Disconnect();
 
    // update networking ports (this is mainly just needed at startup)
    NetConn_UpdateSockets();
 
    cls.protocol = PROTOCOL_QUAKE;
 
    Con_Printf("Playing demo %s.\n", name);
    cls.demofile = f;
    dp_strlcpy(cls.demoname, name, sizeof(cls.demoname));
 
    cls.demoplayback = true;
    cls.state = ca_connected;
    cls.forcetrack = 0;
 
    while ((c = FS_Getc (cls.demofile)) != '\n')
        if (c == '-')
            neg = true;
        else
            cls.forcetrack = cls.forcetrack * 10 + (c - '0');
 
    if (neg)
        cls.forcetrack = -cls.forcetrack;
 
    cls.demostarting = false;
}

References ca_connected, CL_Disconnect(), cls, CON_ERROR, Con_Printf(), client_static_t::demofile, client_static_t::demoname, client_static_t::demonum, client_static_t::demoplayback, client_static_t::demostarting, dp_strlcpy, f, client_static_t::forcetrack, FS_DefaultExtension(), FS_Getc(), FS_OpenVirtualFile(), MAX_QPATH, name, NetConn_UpdateSockets(), client_static_t::protocol, PROTOCOL_QUAKE, and client_static_t::state.

Referenced by CL_PlayDemo_f(), and CL_TimeDemo_f().

◆ CL_PlayDemo_f()

void CL_PlayDemo_f ( cmd_state_t * cmd )

Definition at line 468 of file cl_demo.c.

{
    if (Cmd_Argc(cmd) != 2)
    {
        Con_Print("playdemo <demoname> : plays a demo\n");
        return;
    }
 
    CL_PlayDemo(Cmd_Argv(cmd, 1));
}

References CL_PlayDemo(), cmd(), Cmd_Argc(), Cmd_Argv(), and Con_Print().

Referenced by CL_Demo_Init().

◆ CL_ReadDemoMessage()

void CL_ReadDemoMessage ( void )

Definition at line 187 of file cl_demo.c.

{
    int i;
    float f;
 
    if (!cls.demoplayback)
        return;
 
    // LadyHavoc: pausedemo
    if (cls.demopaused)
        return;
 
    for (;;)
    {
        // decide if it is time to grab the next message
        // always grab until fully connected
        if (cls.signon == SIGNONS)
        {
            if (cls.timedemo)
            {
                cls.td_frames++;
                cls.td_onesecondframes++;
                // if this is the first official frame we can now grab the real
                // td_starttime so the bogus time on the first frame doesn't
                // count against the final report
                if (cls.td_frames == 0)
                {
                    cls.td_starttime = host.realtime;
                    cls.td_onesecondnexttime = cl.time + 1;
                    cls.td_onesecondrealtime = host.realtime;
                    cls.td_onesecondframes = 0;
                    cls.td_onesecondminfps = 0;
                    cls.td_onesecondmaxfps = 0;
                    cls.td_onesecondavgfps = 0;
                    cls.td_onesecondavgcount = 0;
                }
                if (cl.time >= cls.td_onesecondnexttime)
                {
                    double fps = cls.td_onesecondframes / (host.realtime - cls.td_onesecondrealtime);
                    if (cls.td_onesecondavgcount == 0)
                    {
                        cls.td_onesecondminfps = fps;
                        cls.td_onesecondmaxfps = fps;
                    }
                    cls.td_onesecondrealtime = host.realtime;
                    cls.td_onesecondminfps = min(cls.td_onesecondminfps, fps);
                    cls.td_onesecondmaxfps = max(cls.td_onesecondmaxfps, fps);
                    cls.td_onesecondavgfps += fps;
                    cls.td_onesecondavgcount++;
                    cls.td_onesecondframes = 0;
                    cls.td_onesecondnexttime++;
                }
            }
            else if (cl.time < cl.mtime[0])
            {
                // don't need another message yet
                return;
            }
        }
 
        /* At signon 1 the cl_begindownloads command starts the world and, if applicable,
         * boots up CSQC which may be required to parse the next message.
         * That will be delayed if curl must first (down)load the map.
         */
        if (cls.signon == 1 && cl.loadcsqc) // waiting for CL_VM_Init() to be called
            return;
 
        // get the next message
        FS_Read(cls.demofile, &cl_message.cursize, 4);
        cl_message.cursize = LittleLong(cl_message.cursize);
        if(cl_message.cursize & DEMOMSG_CLIENT_TO_SERVER) // This is a client->server message! Ignore for now!
        {
            // skip over demo packet
            FS_Seek(cls.demofile, 12 + (cl_message.cursize & (~DEMOMSG_CLIENT_TO_SERVER)), SEEK_CUR);
            continue;
        }
        if (cl_message.cursize > cl_message.maxsize)
        {
            CL_DisconnectEx(false, "Demo message (%i) > cl_message.maxsize (%i)", cl_message.cursize, cl_message.maxsize);
            cl_message.cursize = 0;
            return;
        }
        VectorCopy(cl.mviewangles[0], cl.mviewangles[1]);
        for (i = 0;i < 3;i++)
        {
            FS_Read(cls.demofile, &f, 4);
            cl.mviewangles[0][i] = LittleFloat(f);
        }
 
        if (FS_Read(cls.demofile, cl_message.data, cl_message.cursize) == cl_message.cursize)
        {
            MSG_BeginReading(&cl_message);
            CL_ParseServerMessage();
 
            if (cls.signon != SIGNONS)
                Cbuf_Execute((cmd_local)->cbuf); // immediately execute svc_stufftext if in the demo before connect!
 
            // In case the demo contains a "svc_disconnect" message
            if (!cls.demoplayback)
                return;
 
            if (cls.timedemo)
                return;
        }
        else
        {
            CL_Disconnect();
            return;
        }
    }
}

Referenced by CL_Frame().

◆ CL_Record_f()

void CL_Record_f ( cmd_state_t * cmd )

Definition at line 346 of file cl_demo.c.

{
    int c, track;
    char name[MAX_OSPATH];
    char vabuf[1024];
    int vabuf_len;
 
    c = Cmd_Argc(cmd);
    if (c != 2 && c != 3 && c != 4)
    {
        Con_Print("record <demoname> [<map> [cd track]]\n");
        return;
    }
 
    if (strstr(Cmd_Argv(cmd, 1), ".."))
    {
        Con_Print("Relative pathnames are not allowed.\n");
        return;
    }
 
    if (c == 2 && cls.state == ca_connected)
    {
        Con_Print("Can not record - already connected to server\nClient demo recording must be started before connecting\n");
        return;
    }
 
    if (cls.state == ca_connected)
        CL_Disconnect();
 
    // write the forced cd track number, or -1
    if (c == 4)
    {
        track = atoi(Cmd_Argv(cmd, 3));
        Con_Printf("Forcing CD track to %i\n", cls.forcetrack);
    }
    else
        track = -1;
 
    // get the demo name
    dp_strlcpy (name, Cmd_Argv(cmd, 1), sizeof (name));
    FS_DefaultExtension (name, ".dem", sizeof (name));
 
    // start the map up
    if (c > 2)
    {
        vabuf_len = dpsnprintf(vabuf, sizeof(vabuf), "map %s", Cmd_Argv(cmd, 2));
        Cmd_ExecuteString(cmd, vabuf, vabuf_len, src_local, false);
    }
 
    // open the demo file
    Con_Printf("recording to %s.\n", name);
    cls.demofile = FS_OpenRealFile(name, "wb", false);
    if (!cls.demofile)
    {
        Con_Print(CON_ERROR "ERROR: couldn't open.\n");
        return;
    }
    dp_strlcpy(cls.demoname, name, sizeof(cls.demoname));
 
    cls.forcetrack = track;
    FS_Printf(cls.demofile, "%i\n", cls.forcetrack);
 
    cls.demorecording = true;
    cls.demo_lastcsprogssize = -1;
    cls.demo_lastcsprogscrc = -1;
}

References ca_connected, CL_Disconnect(), cls, cmd(), Cmd_Argc(), Cmd_Argv(), Cmd_ExecuteString(), CON_ERROR, Con_Print(), Con_Printf(), client_static_t::demo_lastcsprogscrc, client_static_t::demo_lastcsprogssize, client_static_t::demofile, client_static_t::demoname, client_static_t::demorecording, dp_strlcpy, dpsnprintf(), client_static_t::forcetrack, FS_DefaultExtension(), FS_OpenRealFile(), FS_Printf(), MAX_OSPATH, name, src_local, and client_static_t::state.

Referenced by CL_Demo_Init().

◆ CL_RelinkBeams()

void CL_RelinkBeams ( void )

Definition at line 1884 of file cl_main.c.

{
    int i;
    beam_t *b;
    vec3_t dist, org, start, end;
    float d;
    entity_render_t *entrender;
    double yaw, pitch;
    float forward;
    matrix4x4_t tempmatrix;
 
    for (i = 0, b = cl.beams;i < cl.num_beams;i++, b++)
    {
        if (!b->model)
            continue;
        if (b->endtime < cl.time)
        {
            b->model = NULL;
            continue;
        }
 
        CL_Beam_CalculatePositions(b, start, end);
 
        if (b->lightning)
        {
            if (cl_beams_lightatend.integer && r_refdef.scene.numlights < MAX_DLIGHTS)
            {
                // FIXME: create a matrix from the beam start/end orientation
                vec3_t dlightcolor;
                VectorSet(dlightcolor, 0.3, 0.7, 1);
                Matrix4x4_CreateFromQuakeEntity(&tempmatrix, end[0], end[1], end[2], 0, 0, 0, 200);
                R_RTLight_Update(&r_refdef.scene.templights[r_refdef.scene.numlights], false, &tempmatrix, dlightcolor, -1, NULL, true, 1, 0.25, 1, 0, 0, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
                r_refdef.scene.lights[r_refdef.scene.numlights] = &r_refdef.scene.templights[r_refdef.scene.numlights];r_refdef.scene.numlights++;
            }
            if (cl_beams_polygons.integer)
            {
                CL_Beam_AddPolygons(b);
                continue;
            }
        }
 
        // calculate pitch and yaw
        // (this is similar to the QuakeC builtin function vectoangles)
        VectorSubtract(end, start, dist);
        if (dist[1] == 0 && dist[0] == 0)
        {
            yaw = 0;
            if (dist[2] > 0)
                pitch = 90;
            else
                pitch = 270;
        }
        else
        {
            yaw = atan2(dist[1], dist[0]) * 180 / M_PI;
            if (yaw < 0)
                yaw += 360;
 
            forward = sqrt (dist[0]*dist[0] + dist[1]*dist[1]);
            pitch = atan2(dist[2], forward) * 180 / M_PI;
            if (pitch < 0)
                pitch += 360;
        }
 
        // add new entities for the lightning
        VectorCopy (start, org);
        d = VectorNormalizeLength(dist);
        while (d > 0)
        {
            entrender = CL_NewTempEntity (0);
            if (!entrender)
                return;
            entrender->model = b->model;
            Matrix4x4_CreateFromQuakeEntity(&entrender->matrix, org[0], org[1], org[2], -pitch, yaw, lhrandom(0, 360), 1);
            CL_UpdateRenderEntity(entrender);
            VectorMA(org, 30, dist, org);
            d -= 30;
        }
    }
 
    while (cl.num_beams > 0 && !cl.beams[cl.num_beams - 1].model)
        cl.num_beams--;
}

References b, client_state_t::beams, cl, CL_Beam_AddPolygons(), CL_Beam_CalculatePositions(), cl_beams_lightatend, cl_beams_polygons, CL_NewTempEntity(), CL_UpdateRenderEntity(), forward, i, cvar_t::integer, lhrandom, LIGHTFLAG_NORMALMODE, LIGHTFLAG_REALTIMEMODE, r_refdef_scene_t::lights, M_PI, entity_render_t::matrix, Matrix4x4_CreateFromQuakeEntity(), MAX_DLIGHTS, beam_t::model, entity_render_t::model, NULL, client_state_t::num_beams, r_refdef_scene_t::numlights, r_refdef, R_RTLight_Update(), r_refdef_t::scene, sqrt(), r_refdef_scene_t::templights, client_state_t::time, VectorCopy, VectorMA, VectorNormalizeLength(), VectorSet, and VectorSubtract.

Referenced by CSQC_RelinkAllEntities().

◆ CL_RelinkLightFlashes()

void CL_RelinkLightFlashes ( void )

Definition at line 935 of file cl_main.c.

{
    int i, j, k, l;
    dlight_t *dl;
    float frac, f;
    matrix4x4_t tempmatrix;
 
    if (r_dynamic.integer)
    {
        for (i = 0, dl = cl.dlights;i < cl.num_dlights && r_refdef.scene.numlights < MAX_DLIGHTS;i++, dl++)
        {
            if (dl->radius)
            {
                tempmatrix = dl->matrix;
                Matrix4x4_Scale(&tempmatrix, dl->radius, 1);
                // we need the corona fading to be persistent
                R_RTLight_Update(&dl->rtlight, false, &tempmatrix, dl->color, dl->style, dl->cubemapname, dl->shadow, dl->corona, dl->coronasizescale, dl->ambientscale, dl->diffusescale, dl->specularscale, dl->flags);
                r_refdef.scene.lights[r_refdef.scene.numlights++] = &dl->rtlight;
            }
        }
    }
 
    if (!cl.lightstyle)
    {
        for (j = 0;j < cl.max_lightstyle;j++)
        {
            r_refdef.scene.rtlightstylevalue[j] = 1;
            r_refdef.scene.lightstylevalue[j] = 256;
        }
        return;
    }
 
// light animations
// 'm' is normal light, 'a' is no light, 'z' is double bright
    f = cl.time * 10;
    i = (int)floor(f);
    frac = f - i;
    for (j = 0;j < cl.max_lightstyle;j++)
    {
        if (!cl.lightstyle[j].length)
        {
            r_refdef.scene.rtlightstylevalue[j] = 1;
            r_refdef.scene.lightstylevalue[j] = 256;
            continue;
        }
        // static lightstyle "=value"
        if (cl.lightstyle[j].map[0] == '=')
        {
            r_refdef.scene.rtlightstylevalue[j] = atof(cl.lightstyle[j].map + 1);
            if ( r_lerplightstyles.integer || ((int)f - f) < 0.01)
                r_refdef.scene.lightstylevalue[j] = r_refdef.scene.rtlightstylevalue[j];
            continue;
        }
        k = i % cl.lightstyle[j].length;
        l = (i-1) % cl.lightstyle[j].length;
        k = cl.lightstyle[j].map[k] - 'a';
        l = cl.lightstyle[j].map[l] - 'a';
        // rtlightstylevalue is always interpolated because it has no bad
        // consequences for performance
        // lightstylevalue is subject to a cvar for performance reasons;
        // skipping lightmap updates on most rendered frames substantially
        // improves framerates (but makes light fades look bad)
        r_refdef.scene.rtlightstylevalue[j] = ((k*frac)+(l*(1-frac)))*(22/256.0f);
        r_refdef.scene.lightstylevalue[j] = r_lerplightstyles.integer ? (unsigned short)(((k*frac)+(l*(1-frac)))*22) : k*22;
    }
}

References dlight_t::ambientscale, cl, dlight_t::color, dlight_t::corona, dlight_t::coronasizescale, dlight_t::cubemapname, dlight_t::diffusescale, client_state_t::dlights, f, dlight_t::flags, floor(), i, int(), cvar_t::integer, lightstyle_t::length, r_refdef_scene_t::lights, client_state_t::lightstyle, r_refdef_scene_t::lightstylevalue, lightstyle_t::map, dlight_t::matrix, Matrix4x4_Scale(), MAX_DLIGHTS, client_state_t::max_lightstyle, client_state_t::num_dlights, r_refdef_scene_t::numlights, r_dynamic, r_lerplightstyles, r_refdef, R_RTLight_Update(), dlight_t::radius, dlight_t::rtlight, r_refdef_scene_t::rtlightstylevalue, r_refdef_t::scene, dlight_t::shadow, dlight_t::specularscale, dlight_t::style, and client_state_t::time.

Referenced by CSQC_RelinkAllEntities().

◆ CL_RotateMoves()

void CL_RotateMoves ( const matrix4x4_t * m )

Definition at line 1746 of file cl_input.c.

{
    // rotate viewangles in all previous moves
    vec3_t v;
    vec3_t f, r, u;
    int i;
    for (i = 0;i < CL_MAX_USERCMDS;i++)
    {
        if (cl.movecmd[i].sequence > cls.servermovesequence)
        {
            usercmd_t *c = &cl.movecmd[i];
            AngleVectors(c->viewangles, f, r, u);
            Matrix4x4_Transform(m, f, v); VectorCopy(v, f);
            Matrix4x4_Transform(m, u, v); VectorCopy(v, u);
            AnglesFromVectors(c->viewangles, f, u, false);
        }
    }
}

References AnglesFromVectors(), AngleVectors(), cl, CL_MAX_USERCMDS, cls, f, i, Matrix4x4_Transform(), client_state_t::movecmd, r, usercmd_t::sequence, client_static_t::servermovesequence, v, VectorCopy, and usercmd_t::viewangles.

Referenced by VM_CL_RotateMoves().

◆ CL_SendMove()

void CL_SendMove ( void )

Definition at line 1771 of file cl_input.c.

{
    int i, j, packetloss;
    int checksumindex;
    int bits;
    int maxusercmds;
    usercmd_t *cmd;
    sizebuf_t buf;
    unsigned char data[1024];
    float packettime, lag;
    qbool opportune_moment;
    qbool quemove;
    qbool important;
 
    // if playing a demo, do nothing
    if (!cls.netcon)
        return;
 
    // we don't que moves during a lag spike (potential network timeout)
    quemove = host.realtime - cl.last_received_message < cl_movement_nettimeout.value;
 
    // we build up cl.cmd and then decide whether to send or not
    // we store this into cl.movecmd[0] for prediction each frame even if we
    // do not send, to make sure that prediction is instant
    cl.cmd.time = cl.time;
    cl.cmd.sequence = cls.netcon->outgoing_unreliable_sequence;
 
    // set button bits
    // LadyHavoc: added 6 new buttons and use and chat buttons, and prydon cursor active button
    bits = 0;
    if (in_attack.state   & 3) bits |=   1;
    if (in_jump.state     & 3) bits |=   2;
    if (in_button3.state  & 3) bits |=   4;
    if (in_button4.state  & 3) bits |=   8;
    if (in_button5.state  & 3) bits |=  16;
    if (in_button6.state  & 3) bits |=  32;
    if (in_button7.state  & 3) bits |=  64;
    if (in_button8.state  & 3) bits |= 128;
    if (in_use.state      & 3) bits |= 256;
    if (key_dest != key_game || key_consoleactive || !vid_activewindow) bits |= 512;
    if (cl_prydoncursor.integer > 0) bits |= 1024;
    if (in_button9.state  & 3)  bits |=   2048;
    if (in_button10.state  & 3) bits |=   4096;
    if (in_button11.state  & 3) bits |=   8192;
    if (in_button12.state  & 3) bits |=  16384;
    if (in_button13.state  & 3) bits |=  32768;
    if (in_button14.state  & 3) bits |=  65536;
    if (in_button15.state  & 3) bits |= 131072;
    if (in_button16.state  & 3) bits |= 262144;
    // button bits 19-31 unused currently
    // rotate/zoom view serverside if PRYDON_CLIENTCURSOR cursor is at edge of screen
    if(cl_prydoncursor.integer > 0)
    {
        if (cl.cmd.cursor_screen[0] <= -1) bits |= 8;
        if (cl.cmd.cursor_screen[0] >=  1) bits |= 16;
        if (cl.cmd.cursor_screen[1] <= -1) bits |= 32;
        if (cl.cmd.cursor_screen[1] >=  1) bits |= 64;
    }
 
    // set buttons and impulse
    cl.cmd.buttons = bits;
    cl.cmd.impulse = in_impulse;
 
    // set viewangles
    VectorCopy(cl.viewangles, cl.cmd.viewangles);
 
    // bones_was_here: previously cl.cmd.frametime was floored to nearest millisec
    // this meant the smoothest async movement required integer millisec
    // client and server frame times (eg 125fps)
    cl.cmd.frametime = bound(0.0, cl.cmd.time - cl.movecmd[1].time, 0.255);
    // ridiculous value rejection (matches qw)
    if (cl.cmd.frametime > 0.25)
        cl.cmd.frametime = 0.1;
    cl.cmd.msec = (unsigned char)floor(cl.cmd.frametime * 1000);
 
    switch(cls.protocol)
    {
    case PROTOCOL_QUAKEWORLD:
        // quakeworld uses a different cvar with opposite meaning, for compatibility
        cl.cmd.predicted = cl_nopred.integer == 0;
        break;
    case PROTOCOL_DARKPLACES6:
    case PROTOCOL_DARKPLACES7:
    case PROTOCOL_DARKPLACES8:
        cl.cmd.predicted = cl_movement.integer != 0;
        break;
    default:
        cl.cmd.predicted = false;
        break;
    }
 
    // movement is set by input code (forwardmove/sidemove/upmove)
    // always dump the first two moves, because they may contain leftover inputs from the last level
    if (cl.cmd.sequence <= 2)
        cl.cmd.forwardmove = cl.cmd.sidemove = cl.cmd.upmove = cl.cmd.impulse = cl.cmd.buttons = 0;
 
    cl.cmd.jump = (cl.cmd.buttons & 2) != 0;
    cl.cmd.crouch = 0;
    switch (cls.protocol)
    {
    case PROTOCOL_QUAKEWORLD:
    case PROTOCOL_QUAKE:
    case PROTOCOL_QUAKEDP:
    case PROTOCOL_NEHAHRAMOVIE:
    case PROTOCOL_NEHAHRABJP:
    case PROTOCOL_NEHAHRABJP2:
    case PROTOCOL_NEHAHRABJP3:
    case PROTOCOL_DARKPLACES1:
    case PROTOCOL_DARKPLACES2:
    case PROTOCOL_DARKPLACES3:
    case PROTOCOL_DARKPLACES4:
    case PROTOCOL_DARKPLACES5:
        break;
    case PROTOCOL_DARKPLACES6:
    case PROTOCOL_DARKPLACES7:
    case PROTOCOL_DARKPLACES8:
        // FIXME: cl.cmd.buttons & 16 is +button5, Nexuiz/Xonotic specific
        cl.cmd.crouch = (cl.cmd.buttons & 16) != 0;
        break;
    case PROTOCOL_UNKNOWN:
        break;
    }
 
    if (quemove)
        cl.movecmd[0] = cl.cmd;
 
    /* Accumulating cl.realframetime to prevent low packet rates,
     * previously with cl_maxfps == cl_netfps it did not send every frame because
     * host.realtime - cl.lastpackettime was often well below (or above) cl_packetinterval.
     */
    cl.timesincepacket += cl.realframetime;
 
    // don't predict more than 256fps
    if (cl.timesincepacket >= 1/256)
        cl.movement_replay = true; // redo the prediction
 
    // now decide whether to actually send this move
    // (otherwise it is only for prediction)
 
    // do not send 0ms packets because they mess up physics
    // DP servers discard (treat like lost) predicted moves shorter than 0.0005s
    // the time advancing check must be unaffected by time sync as it may have caused the short move
    if(cl.cmd.msec == 0 && cl.mtime[0] > cl.mtime[1] && (cls.protocol == PROTOCOL_QUAKEWORLD || cls.signon == SIGNONS))
        return;
 
    // don't send too often or else network connections can get clogged by a
    // high renderer framerate
    packettime = 1.0f / bound(10.0f, cl_netfps.value, 1000.0f);
    if (cl.movevars_ticrate)
        packettime = bound(cl.movevars_ticrate * 0.5f, packettime, cl.movevars_ticrate);
 
    // always send if buttons changed or an impulse is pending
    // even if it violates the rate limit!
    important = (cl.cmd.impulse || (cl_netimmediatebuttons.integer && cl.cmd.buttons != cl.movecmd[1].buttons));
 
    // improve and stabilise ping by synchronising with the server
    lag = cl.mtime[0] - cl.cmd.time;
    //    unknown ticrate    ||     PL or ping spike      || loading
    if (!cl.movevars_ticrate || lag > cl.movevars_ticrate || lag < 0)
        opportune_moment = false;
    else // sync should be possible
    {
        float frames_per_tic = cl.movevars_ticrate / cl.realframetime;
        opportune_moment = lag < 0.999f * (float)cl.realframetime * (frames_per_tic <= 1 ? 1 : sqrtf(frames_per_tic));
    }
 
    // don't send too often (cl_netfps)
    if (!important && cl.timesincepacket < packettime * 0.999f
    && (!opportune_moment || cl.opt_inputs_since_update))
    {
//      Con_Printf("^1moveft %f realft %f lag %f tic %f inputsince %d opp %d\n", cl.cmd.frametime, cl.realframetime, lag, cl.movevars_ticrate, cl.opt_inputs_since_update, opportune_moment);
        return;
    }
 
    // don't choke the connection with packets (obey rate limit)
    // it is important that this check be last, because it adds a new
    // frame to the shownetgraph output and any cancelation after this
    // will produce a nasty spike-like look to the netgraph
    // we also still send if it is important
    if (!NetConn_CanSend(cls.netcon) && !important)
        return;
 
//  Con_Printf("%smoveft %f realft %f lag %f tic %f inputsince %d opp %d import %d\n", (lag < 0.0005 || !opportune_moment) ? "^3" : "^2", cl.cmd.frametime, cl.realframetime, lag, cl.movevars_ticrate, cl.opt_inputs_since_update, opportune_moment, important);
 
    if (opportune_moment)
        ++cl.opt_inputs_since_update;
    cl.timesincepacket = 0;
 
    buf.maxsize = sizeof(data);
    buf.cursize = 0;
    buf.data = data;
 
    // send the movement message
    // PROTOCOL_QUAKE        clc_move = 16 bytes total
    // PROTOCOL_QUAKEDP      clc_move = 16 bytes total
    // PROTOCOL_NEHAHRAMOVIE clc_move = 16 bytes total
    // PROTOCOL_DARKPLACES1  clc_move = 19 bytes total
    // PROTOCOL_DARKPLACES2  clc_move = 25 bytes total
    // PROTOCOL_DARKPLACES3  clc_move = 25 bytes total
    // PROTOCOL_DARKPLACES4  clc_move = 19 bytes total
    // PROTOCOL_DARKPLACES5  clc_move = 19 bytes total
    // PROTOCOL_DARKPLACES6  clc_move = 52 bytes total
    // PROTOCOL_DARKPLACES7  clc_move = 56 bytes total per move (can be up to 16 moves)
    // PROTOCOL_DARKPLACES8  clc_move = 56 bytes total per move (can be up to 16 moves)
    // PROTOCOL_QUAKEWORLD   clc_move = 34 bytes total (typically, but can reach 43 bytes, or even 49 bytes with roll)
 
    // set prydon cursor info
    CL_UpdatePrydonCursor();
 
    if (cls.protocol == PROTOCOL_QUAKEWORLD || cls.signon == SIGNONS)
    {
        switch (cls.protocol)
        {
        case PROTOCOL_QUAKEWORLD:
            MSG_WriteByte(&buf, qw_clc_move);
            // save the position for a checksum byte
            checksumindex = buf.cursize;
            MSG_WriteByte(&buf, 0);
            // packet loss percentage
            for (j = 0, packetloss = 0;j < NETGRAPH_PACKETS;j++)
                if (cls.netcon->incoming_netgraph[j].unreliablebytes == NETGRAPH_LOSTPACKET)
                    packetloss++;
            packetloss = packetloss * 100 / NETGRAPH_PACKETS;
            MSG_WriteByte(&buf, packetloss);
            // write most recent 3 moves
            QW_MSG_WriteDeltaUsercmd(&buf, &nullcmd, &cl.movecmd[2]);
            QW_MSG_WriteDeltaUsercmd(&buf, &cl.movecmd[2], &cl.movecmd[1]);
            QW_MSG_WriteDeltaUsercmd(&buf, &cl.movecmd[1], &cl.cmd);
            // calculate the checksum
            buf.data[checksumindex] = COM_BlockSequenceCRCByteQW(buf.data + checksumindex + 1, buf.cursize - checksumindex - 1, cls.netcon->outgoing_unreliable_sequence);
            // if delta compression history overflows, request no delta
            if (cls.netcon->outgoing_unreliable_sequence - cl.qw_validsequence >= QW_UPDATE_BACKUP-1)
                cl.qw_validsequence = 0;
            // request delta compression if appropriate
            if (cl.qw_validsequence && !cl_nodelta.integer && cls.state == ca_connected && !cls.demorecording)
            {
                cl.qw_deltasequence[cls.netcon->outgoing_unreliable_sequence & QW_UPDATE_MASK] = cl.qw_validsequence;
                MSG_WriteByte(&buf, qw_clc_delta);
                MSG_WriteByte(&buf, cl.qw_validsequence & 255);
            }
            else
                cl.qw_deltasequence[cls.netcon->outgoing_unreliable_sequence & QW_UPDATE_MASK] = -1;
            break;
        case PROTOCOL_QUAKE:
        case PROTOCOL_QUAKEDP:
        case PROTOCOL_NEHAHRAMOVIE:
        case PROTOCOL_NEHAHRABJP:
        case PROTOCOL_NEHAHRABJP2:
        case PROTOCOL_NEHAHRABJP3:
            // 5 bytes
            MSG_WriteByte (&buf, clc_move);
            MSG_WriteFloat (&buf, cl.cmd.time); // last server packet time
            // 3 bytes (6 bytes in proquake)
            if (cls.proquake_servermod == 1) // MOD_PROQUAKE
            {
                for (i = 0;i < 3;i++)
                    MSG_WriteAngle16i (&buf, cl.cmd.viewangles[i]);
            }
            else
            {
                for (i = 0;i < 3;i++)
                    MSG_WriteAngle8i (&buf, cl.cmd.viewangles[i]);
            }
            // 6 bytes
            MSG_WriteCoord16i (&buf, cl.cmd.forwardmove);
            MSG_WriteCoord16i (&buf, cl.cmd.sidemove);
            MSG_WriteCoord16i (&buf, cl.cmd.upmove);
            // 2 bytes
            MSG_WriteByte (&buf, cl.cmd.buttons);
            MSG_WriteByte (&buf, cl.cmd.impulse);
            break;
        case PROTOCOL_DARKPLACES2:
        case PROTOCOL_DARKPLACES3:
            // 5 bytes
            MSG_WriteByte (&buf, clc_move);
            MSG_WriteFloat (&buf, cl.cmd.time); // last server packet time
            // 12 bytes
            for (i = 0;i < 3;i++)
                MSG_WriteAngle32f (&buf, cl.cmd.viewangles[i]);
            // 6 bytes
            MSG_WriteCoord16i (&buf, cl.cmd.forwardmove);
            MSG_WriteCoord16i (&buf, cl.cmd.sidemove);
            MSG_WriteCoord16i (&buf, cl.cmd.upmove);
            // 2 bytes
            MSG_WriteByte (&buf, cl.cmd.buttons);
            MSG_WriteByte (&buf, cl.cmd.impulse);
            break;
        case PROTOCOL_DARKPLACES1:
        case PROTOCOL_DARKPLACES4:
        case PROTOCOL_DARKPLACES5:
            // 5 bytes
            MSG_WriteByte (&buf, clc_move);
            MSG_WriteFloat (&buf, cl.cmd.time); // last server packet time
            // 6 bytes
            for (i = 0;i < 3;i++)
                MSG_WriteAngle16i (&buf, cl.cmd.viewangles[i]);
            // 6 bytes
            MSG_WriteCoord16i (&buf, cl.cmd.forwardmove);
            MSG_WriteCoord16i (&buf, cl.cmd.sidemove);
            MSG_WriteCoord16i (&buf, cl.cmd.upmove);
            // 2 bytes
            MSG_WriteByte (&buf, cl.cmd.buttons);
            MSG_WriteByte (&buf, cl.cmd.impulse);
        case PROTOCOL_DARKPLACES6:
        case PROTOCOL_DARKPLACES7:
        case PROTOCOL_DARKPLACES8:
            // set the maxusercmds variable to limit how many should be sent
            maxusercmds = bound(1, cl_netrepeatinput.integer + 1, min(3, CL_MAX_USERCMDS));
            // when movement prediction is off, there's not much point in repeating old input as it will just be ignored
            if (!cl.cmd.predicted)
                maxusercmds = 1;
 
            // send the latest moves in order, the old ones will be
            // ignored by the server harmlessly, however if the previous
            // packets were lost these moves will be used
            //
            // this reduces packet loss impact on gameplay.
            for (j = 0, cmd = &cl.movecmd[maxusercmds-1];j < maxusercmds;j++, cmd--)
            {
                // don't repeat any stale moves
                if (cmd->sequence && cmd->sequence < cls.servermovesequence)
                    continue;
                // 5/9 bytes
                MSG_WriteByte (&buf, clc_move);
                if (cls.protocol != PROTOCOL_DARKPLACES6)
                    MSG_WriteLong (&buf, cmd->predicted ? cmd->sequence : 0);
                MSG_WriteFloat (&buf, cmd->time); // last server packet time
                // 6 bytes
                for (i = 0;i < 3;i++)
                    MSG_WriteAngle16i (&buf, cmd->viewangles[i]);
                // 6 bytes
                MSG_WriteCoord16i (&buf, cmd->forwardmove);
                MSG_WriteCoord16i (&buf, cmd->sidemove);
                MSG_WriteCoord16i (&buf, cmd->upmove);
                // 5 bytes
                MSG_WriteLong (&buf, cmd->buttons);
                MSG_WriteByte (&buf, cmd->impulse);
                // PRYDON_CLIENTCURSOR
                // 30 bytes
                MSG_WriteShort (&buf, (short)(cmd->cursor_screen[0] * 32767.0f));
                MSG_WriteShort (&buf, (short)(cmd->cursor_screen[1] * 32767.0f));
                MSG_WriteFloat (&buf, cmd->cursor_start[0]);
                MSG_WriteFloat (&buf, cmd->cursor_start[1]);
                MSG_WriteFloat (&buf, cmd->cursor_start[2]);
                MSG_WriteFloat (&buf, cmd->cursor_impact[0]);
                MSG_WriteFloat (&buf, cmd->cursor_impact[1]);
                MSG_WriteFloat (&buf, cmd->cursor_impact[2]);
                MSG_WriteShort (&buf, cmd->cursor_entitynumber);
            }
            break;
        case PROTOCOL_UNKNOWN:
            break;
        }
    }
 
    if (cls.protocol != PROTOCOL_QUAKEWORLD && buf.cursize)
    {
        // ack entity frame numbers received since the last input was sent
        // (redundent to improve handling of client->server packet loss)
        // if cl_netrepeatinput is 1 and client framerate matches server
        // framerate, this is 10 bytes, if client framerate is lower this
        // will be more...
        unsigned int oldsequence = cl.cmd.sequence;
        unsigned int delta = bound(1, cl_netrepeatinput.integer + 1, 3);
        if (oldsequence > delta)
            oldsequence = oldsequence - delta;
        else
            oldsequence = 1;
        for (i = 0;i < LATESTFRAMENUMS;i++)
        {
            j = (cl.latestframenumsposition + i) % LATESTFRAMENUMS;
            if (cl.latestsendnums[j] >= oldsequence)
            {
                if (developer_networkentities.integer >= 10)
                    Con_Printf("send clc_ackframe %i\n", cl.latestframenums[j]);
                MSG_WriteByte(&buf, clc_ackframe);
                MSG_WriteLong(&buf, cl.latestframenums[j]);
            }
        }
    }
 
    // PROTOCOL_DARKPLACES6 = 67 bytes per packet
    // PROTOCOL_DARKPLACES7 = 71 bytes per packet
 
    // acknowledge any recently received data blocks
    for (i = 0;i < CL_MAX_DOWNLOADACKS && (cls.dp_downloadack[i].start || cls.dp_downloadack[i].size);i++)
    {
        MSG_WriteByte(&buf, clc_ackdownloaddata);
        MSG_WriteLong(&buf, cls.dp_downloadack[i].start);
        MSG_WriteShort(&buf, cls.dp_downloadack[i].size);
        cls.dp_downloadack[i].start = 0;
        cls.dp_downloadack[i].size = 0;
    }
 
    // send the reliable message (forwarded commands) if there is one
    if (buf.cursize || cls.netcon->message.cursize)
        NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol, max(20*(buf.cursize+40), cl_rate.integer), cl_rate_burstsize.integer, false);
 
    if (quemove)
    {
        // update the cl.movecmd array which holds the most recent moves,
        // because we now need a new slot for the next input
        for (i = CL_MAX_USERCMDS - 1;i >= 1;i--)
            cl.movecmd[i] = cl.movecmd[i-1];
        cl.movecmd[0].msec = 0;
        cl.movecmd[0].frametime = 0;
    }
 
    // clear button 'click' states
    in_attack.state  &= ~2;
    in_jump.state    &= ~2;
    in_button3.state &= ~2;
    in_button4.state &= ~2;
    in_button5.state &= ~2;
    in_button6.state &= ~2;
    in_button7.state &= ~2;
    in_button8.state &= ~2;
    in_use.state     &= ~2;
    in_button9.state  &= ~2;
    in_button10.state &= ~2;
    in_button11.state &= ~2;
    in_button12.state &= ~2;
    in_button13.state &= ~2;
    in_button14.state &= ~2;
    in_button15.state &= ~2;
    in_button16.state &= ~2;
    // clear impulse
    in_impulse = 0;
 
    if (cls.netcon->message.overflowed)
        CL_DisconnectEx(true, "Lost connection to server");
}

Referenced by CL_Frame().

◆ CL_SetEntityColormapColors()

void CL_SetEntityColormapColors	(	entity_render_t *	ent,
		int	colormap )

Definition at line 1061 of file cl_main.c.

{
    const unsigned char *cbcolor;
    if (colormap >= 0)
    {
        cbcolor = palette_rgb_pantscolormap[colormap & 0xF];
        VectorScale(cbcolor, (1.0f / 255.0f), ent->colormap_pantscolor);
        cbcolor = palette_rgb_shirtcolormap[(colormap & 0xF0) >> 4];
        VectorScale(cbcolor, (1.0f / 255.0f), ent->colormap_shirtcolor);
    }
    else
    {
        VectorClear(ent->colormap_pantscolor);
        VectorClear(ent->colormap_shirtcolor);
    }
}

References colormap, entity_render_t::colormap_pantscolor, entity_render_t::colormap_shirtcolor, palette_rgb_pantscolormap, palette_rgb_shirtcolormap, VectorClear, and VectorScale.

Referenced by CL_UpdateNetworkEntity(), and CSQC_AddRenderEdict().

◆ CL_SetInfo()

void CL_SetInfo	(	const char *	key,
		const char *	value,
		qbool	send,
		qbool	allowstarkey,
		qbool	allowmodel,
		qbool	quiet )

Definition at line 233 of file cl_main.c.

{
    int i;
    qbool fail = false;
    char vabuf[1024];
    if (!allowstarkey && key[0] == '*')
        fail = true;
    if (!allowmodel && (!strcasecmp(key, "pmodel") || !strcasecmp(key, "emodel")))
        fail = true;
    for (i = 0;key[i];i++)
        if (ISWHITESPACE(key[i]) || key[i] == '\"')
            fail = true;
    for (i = 0;value[i];i++)
        if (value[i] == '\r' || value[i] == '\n' || value[i] == '\"')
            fail = true;
    if (fail)
    {
        if (!quiet)
            Con_Printf("Can't setinfo \"%s\" \"%s\"\n", key, value);
        return;
    }
    InfoString_SetValue(cls.userinfo, sizeof(cls.userinfo), key, value);
    if (cls.state == ca_connected && cls.netcon)
    {
        if (cls.protocol == PROTOCOL_QUAKEWORLD)
        {
            MSG_WriteByte(&cls.netcon->message, qw_clc_stringcmd);
            MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "setinfo \"%s\" \"%s\"", key, value));
        }
        else if (!strcasecmp(key, "_cl_name") || !strcasecmp(key, "name"))
        {
            MSG_WriteByte(&cls.netcon->message, clc_stringcmd);
            MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "name \"%s\"", value));
        }
        else if (!strcasecmp(key, "playermodel"))
        {
            MSG_WriteByte(&cls.netcon->message, clc_stringcmd);
            MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "playermodel \"%s\"", value));
        }
        else if (!strcasecmp(key, "playerskin"))
        {
            MSG_WriteByte(&cls.netcon->message, clc_stringcmd);
            MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "playerskin \"%s\"", value));
        }
        else if (!strcasecmp(key, "topcolor"))
        {
            MSG_WriteByte(&cls.netcon->message, clc_stringcmd);
            MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "color %i %i", atoi(value), cl_bottomcolor.integer));
        }
        else if (!strcasecmp(key, "bottomcolor"))
        {
            MSG_WriteByte(&cls.netcon->message, clc_stringcmd);
            MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "color %i %i", cl_topcolor.integer, atoi(value)));
        }
        else if (!strcasecmp(key, "rate"))
        {
            MSG_WriteByte(&cls.netcon->message, clc_stringcmd);
            MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "rate \"%s\"", value));
        }
        else if (!strcasecmp(key, "rate_burstsize"))
        {
            MSG_WriteByte(&cls.netcon->message, clc_stringcmd);
            MSG_WriteString(&cls.netcon->message, va(vabuf, sizeof(vabuf), "rate_burstsize \"%s\"", value));
        }
    }
}

References ca_connected, cl_bottomcolor, cl_topcolor, clc_stringcmd, cls, Con_Printf(), i, InfoString_SetValue(), cvar_t::integer, ISWHITESPACE, netconn_t::message, MSG_WriteByte(), MSG_WriteString(), client_static_t::netcon, client_static_t::protocol, PROTOCOL_QUAKEWORLD, qw_clc_stringcmd, client_static_t::state, client_static_t::userinfo, va(), and value.

Referenced by CL_FullInfo_f(), CL_SetInfo_f(), Cvar_SetQuick_Internal(), and QW_CL_RequestNextDownload().

◆ CL_Shutdown()

void CL_Shutdown ( void )

Definition at line 2951 of file cl_main.c.

{
    // be quiet while shutting down
    S_StopAllSounds();
    
    // disconnect client from server if active
    CL_Disconnect();
    
    CL_Video_Shutdown();
 
#ifdef CONFIG_MENU
    // Shutdown menu
    if(MR_Shutdown)
        MR_Shutdown();
#endif
 
    S_Terminate ();
    
    R_Modules_Shutdown();
    VID_Shutdown();
 
    CL_Screen_Shutdown();
    CL_Particles_Shutdown();
    CL_Parse_Shutdown();
    CL_MeshEntities_Shutdown();
 
    Key_Shutdown();
 
    Mem_FreePool (&cls.permanentmempool);
    Mem_FreePool (&cls.levelmempool);
}

References CL_Disconnect(), CL_MeshEntities_Shutdown(), CL_Parse_Shutdown(), CL_Particles_Shutdown(), CL_Screen_Shutdown(), CL_Video_Shutdown(), cls, Key_Shutdown(), client_static_t::levelmempool, Mem_FreePool, MR_Shutdown, client_static_t::permanentmempool, R_Modules_Shutdown(), S_StopAllSounds(), S_Terminate(), and VID_Shutdown().

Referenced by Host_Shutdown().

◆ CL_StartVideo()

void CL_StartVideo ( void )

Definition at line 2786 of file cl_main.c.

{
    if (!vid_opened && cls.state != ca_dedicated)
    {
        vid_opened = true;
#ifdef WIN32
        // make sure we open sockets before opening video because the Windows Firewall "unblock?" dialog can screw up the graphics context on some graphics drivers
        NetConn_UpdateSockets();
#endif
        VID_Start();
    }
}

References ca_dedicated, cls, NetConn_UpdateSockets(), client_static_t::state, vid_opened, and VID_Start().

Referenced by Call_MR_ToggleMenu_f(), CD_f(), CDAudio_Play_byName(), CL_PlayVideo_f(), CL_VideoStart(), Host_Init(), Mod_ForName(), and R_Modules_Restart_f().

◆ CL_Stop_f()

void CL_Stop_f ( cmd_state_t * cmd )

Definition at line 307 of file cl_demo.c.

{
    sizebuf_t buf;
    unsigned char bufdata[64];
 
    if (!cls.demorecording)
    {
        Con_Print("Not recording a demo.\n");
        return;
    }
 
// write a disconnect message to the demo file
    // LadyHavoc: don't replace the cl_message when doing this
    buf.data = bufdata;
    buf.maxsize = sizeof(bufdata);
    SZ_Clear(&buf);
    MSG_WriteByte(&buf, svc_disconnect);
    CL_WriteDemoMessage(&buf);
 
// finish up
    if(cl_autodemo.integer && (cl_autodemo_delete.integer & 1))
    {
        FS_RemoveOnClose(cls.demofile);
        Con_Print("Completed and deleted demo\n");
    }
    else
        Con_Print("Completed demo\n");
    FS_Close (cls.demofile);
    cls.demofile = NULL;
    cls.demorecording = false;
}

References buf, cl_autodemo, cl_autodemo_delete, CL_WriteDemoMessage(), cls, Con_Print(), client_static_t::demofile, client_static_t::demorecording, FS_Close(), FS_RemoveOnClose(), cvar_t::integer, MSG_WriteByte(), NULL, svc_disconnect, and SZ_Clear().

Referenced by CL_Demo_Init(), CL_DisconnectEx(), CL_ParseServerInfo(), and Sys_Error().

◆ CL_StopPlayback()

void CL_StopPlayback ( void )

Definition at line 81 of file cl_demo.c.

{
#ifdef CONFIG_VIDEO_CAPTURE
    if (cl_capturevideo_demo_stop.integer)
        Cvar_SetQuick(&cl_capturevideo, "0");
#endif
 
    if (!cls.demoplayback)
        return;
 
    FS_Close (cls.demofile);
    cls.demoplayback = false;
    cls.demofile = NULL;
 
    if (cls.timedemo)
        CL_FinishTimeDemo ();
 
    if (!cls.demostarting) // only quit if not starting another demo
        if (Sys_CheckParm("-demo") || Sys_CheckParm("-capturedemo"))
            host.state = host_shutdown;
}

References CL_FinishTimeDemo(), cls, Cvar_SetQuick(), client_static_t::demofile, client_static_t::demoplayback, client_static_t::demostarting, FS_Close(), host, host_shutdown, cvar_t::integer, NULL, host_static_t::state, Sys_CheckParm(), and client_static_t::timedemo.

Referenced by CL_DisconnectEx().

◆ CL_TimeDemo_f()

void CL_TimeDemo_f ( cmd_state_t * cmd )

Definition at line 612 of file cl_demo.c.

{
    if (Cmd_Argc(cmd) != 2)
    {
        Con_Print("timedemo <demoname> : gets demo speeds\n");
        return;
    }
 
    srand(0); // predictable random sequence for benchmarking
 
    CL_PlayDemo(Cmd_Argv(cmd, 1));
 
// cls.td_starttime will be grabbed at the second frame of the demo, so
// all the loading time doesn't get counted
 
    // instantly hide console and deactivate it
    key_dest = key_game;
    key_consoleactive = 0;
    scr_con_current = 0;
 
    cls.timedemo = host.restless = true;
    cls.td_frames = -2;     // skip the first frame
    cls.demonum = -1;       // stop demo loop
 
    // Might need to disable vsync
    Cvar_Callback(&vid_vsync);
}

References CL_PlayDemo(), cls, cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), Cvar_Callback(), client_static_t::demonum, host, key_consoleactive, key_dest, key_game, host_static_t::restless, scr_con_current, client_static_t::td_frames, client_static_t::timedemo, and vid_vsync.

Referenced by CL_Demo_Init().

◆ CL_UpdateEntityShading()

void CL_UpdateEntityShading ( void )

Definition at line 2777 of file cl_main.c.

{
    int i;
    CL_UpdateEntityShading_Entity(r_refdef.scene.worldentity);
    for (i = 0; i < r_refdef.scene.numentities; i++)
        CL_UpdateEntityShading_Entity(r_refdef.scene.entities[i]);
}

References CL_UpdateEntityShading_Entity(), r_refdef_scene_t::entities, i, r_refdef_scene_t::numentities, r_refdef, r_refdef_t::scene, and r_refdef_scene_t::worldentity.

Referenced by R_Envmap_f(), SCR_DrawScreen(), and VM_CL_R_RenderScene().

◆ CL_UpdateMoveVars()

void CL_UpdateMoveVars ( void )

Definition at line 1495 of file cl_input.c.

{
    if (cls.protocol == PROTOCOL_QUAKEWORLD)
    {
        cl.moveflags = 0;
    }
    else if (cl.stats[STAT_MOVEVARS_TICRATE])
    {
        cl.moveflags = cl.stats[STAT_MOVEFLAGS];
        cl.movevars_ticrate = cl.statsf[STAT_MOVEVARS_TICRATE];
        cl.movevars_timescale = cl.statsf[STAT_MOVEVARS_TIMESCALE];
        cl.movevars_gravity = cl.statsf[STAT_MOVEVARS_GRAVITY];
        cl.movevars_stopspeed = cl.statsf[STAT_MOVEVARS_STOPSPEED] ;
        cl.movevars_maxspeed = cl.statsf[STAT_MOVEVARS_MAXSPEED];
        cl.movevars_spectatormaxspeed = cl.statsf[STAT_MOVEVARS_SPECTATORMAXSPEED];
        cl.movevars_accelerate = cl.statsf[STAT_MOVEVARS_ACCELERATE];
        cl.movevars_airaccelerate = cl.statsf[STAT_MOVEVARS_AIRACCELERATE];
        cl.movevars_wateraccelerate = cl.statsf[STAT_MOVEVARS_WATERACCELERATE];
        cl.movevars_entgravity = cl.statsf[STAT_MOVEVARS_ENTGRAVITY];
        cl.movevars_jumpvelocity = cl.statsf[STAT_MOVEVARS_JUMPVELOCITY];
        cl.movevars_edgefriction = cl.statsf[STAT_MOVEVARS_EDGEFRICTION];
        cl.movevars_maxairspeed = cl.statsf[STAT_MOVEVARS_MAXAIRSPEED];
        cl.movevars_stepheight = cl.statsf[STAT_MOVEVARS_STEPHEIGHT];
        cl.movevars_airaccel_qw = cl.statsf[STAT_MOVEVARS_AIRACCEL_QW];
        cl.movevars_airaccel_qw_stretchfactor = cl.statsf[STAT_MOVEVARS_AIRACCEL_QW_STRETCHFACTOR];
        cl.movevars_airaccel_sideways_friction = cl.statsf[STAT_MOVEVARS_AIRACCEL_SIDEWAYS_FRICTION];
        cl.movevars_friction = cl.statsf[STAT_MOVEVARS_FRICTION];
        cl.movevars_wallfriction = cl.statsf[STAT_MOVEVARS_WALLFRICTION];
        cl.movevars_waterfriction = cl.statsf[STAT_MOVEVARS_WATERFRICTION];
        cl.movevars_airstopaccelerate = cl.statsf[STAT_MOVEVARS_AIRSTOPACCELERATE];
        cl.movevars_airstrafeaccelerate = cl.statsf[STAT_MOVEVARS_AIRSTRAFEACCELERATE];
        cl.movevars_maxairstrafespeed = cl.statsf[STAT_MOVEVARS_MAXAIRSTRAFESPEED];
        cl.movevars_airstrafeaccel_qw = cl.statsf[STAT_MOVEVARS_AIRSTRAFEACCEL_QW];
        cl.movevars_aircontrol = cl.statsf[STAT_MOVEVARS_AIRCONTROL];
        cl.movevars_aircontrol_power = cl.statsf[STAT_MOVEVARS_AIRCONTROL_POWER];
        cl.movevars_aircontrol_penalty = cl.statsf[STAT_MOVEVARS_AIRCONTROL_PENALTY];
        cl.movevars_warsowbunny_airforwardaccel = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_AIRFORWARDACCEL];
        cl.movevars_warsowbunny_accel = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_ACCEL];
        cl.movevars_warsowbunny_topspeed = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_TOPSPEED];
        cl.movevars_warsowbunny_turnaccel = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_TURNACCEL];
        cl.movevars_warsowbunny_backtosideratio = cl.statsf[STAT_MOVEVARS_WARSOWBUNNY_BACKTOSIDERATIO];
        cl.movevars_airspeedlimit_nonqw = cl.statsf[STAT_MOVEVARS_AIRSPEEDLIMIT_NONQW];
    }
    else
    {
        cl.moveflags = 0;
        cl.movevars_ticrate = 0; // bones_was_here: no guessing, unavailable ticrate triggers better fallbacks
        cl.movevars_timescale = (cls.demoplayback || host_timescale.value <= 0) ? 1.0f : host_timescale.value;
        cl.movevars_gravity = sv_gravity.value;
        cl.movevars_stopspeed = cl_movement_stopspeed.value;
        cl.movevars_maxspeed = cl_movement_maxspeed.value;
        cl.movevars_spectatormaxspeed = cl_movement_maxspeed.value;
        cl.movevars_accelerate = cl_movement_accelerate.value;
        cl.movevars_airaccelerate = cl_movement_airaccelerate.value < 0 ? cl_movement_accelerate.value : cl_movement_airaccelerate.value;
        cl.movevars_wateraccelerate = cl_movement_wateraccelerate.value < 0 ? cl_movement_accelerate.value : cl_movement_wateraccelerate.value;
        cl.movevars_friction = cl_movement_friction.value;
        cl.movevars_wallfriction = cl_movement_wallfriction.value;
        cl.movevars_waterfriction = cl_movement_waterfriction.value < 0 ? cl_movement_friction.value : cl_movement_waterfriction.value;
        cl.movevars_entgravity = 1;
        cl.movevars_jumpvelocity = cl_movement_jumpvelocity.value;
        cl.movevars_edgefriction = cl_movement_edgefriction.value;
        cl.movevars_maxairspeed = cl_movement_maxairspeed.value;
        cl.movevars_stepheight = cl_movement_stepheight.value;
        cl.movevars_airaccel_qw = cl_movement_airaccel_qw.value;
        cl.movevars_airaccel_qw_stretchfactor = 0;
        cl.movevars_airaccel_sideways_friction = cl_movement_airaccel_sideways_friction.value;
        cl.movevars_airstopaccelerate = 0;
        cl.movevars_airstrafeaccelerate = 0;
        cl.movevars_maxairstrafespeed = 0;
        cl.movevars_airstrafeaccel_qw = 0;
        cl.movevars_aircontrol = 0;
        cl.movevars_aircontrol_power = 2;
        cl.movevars_aircontrol_penalty = 0;
        cl.movevars_warsowbunny_airforwardaccel = 0;
        cl.movevars_warsowbunny_accel = 0;
        cl.movevars_warsowbunny_topspeed = 0;
        cl.movevars_warsowbunny_turnaccel = 0;
        cl.movevars_warsowbunny_backtosideratio = 0;
        cl.movevars_airspeedlimit_nonqw = 0;
    }
 
    if(!(cl.moveflags & MOVEFLAG_VALID))
    {
        if(gamemode == GAME_NEXUIZ)  // Legacy hack to work with old servers of Nexuiz.
            cl.moveflags = MOVEFLAG_Q2AIRACCELERATE;
    }
 
    if(cl.movevars_aircontrol_power <= 0)
        cl.movevars_aircontrol_power = 2; // CPMA default
}

Referenced by CL_ParseServerMessage().

◆ CL_UpdateRenderEntity()

void CL_UpdateRenderEntity ( entity_render_t * ent )

Definition at line 702 of file cl_main.c.

{
    vec3_t org;
    vec_t scale;
    model_t *model = ent->model;
    // update the inverse matrix for the renderer
    Matrix4x4_Invert_Simple(&ent->inversematrix, &ent->matrix);
    // update the animation blend state
    VM_FrameBlendFromFrameGroupBlend(ent->frameblend, ent->framegroupblend, ent->model, cl.time);
    // we need the matrix origin to center the box
    Matrix4x4_OriginFromMatrix(&ent->matrix, org);
    // update entity->render.scale because the renderer needs it
    ent->scale = scale = Matrix4x4_ScaleFromMatrix(&ent->matrix);
    if (model)
    {
        // NOTE: this directly extracts vector components from the matrix, which relies on the matrix orientation!
#ifdef MATRIX4x4_OPENGLORIENTATION
        if (ent->matrix.m[0][2] != 0 || ent->matrix.m[1][2] != 0)
#else
        if (ent->matrix.m[2][0] != 0 || ent->matrix.m[2][1] != 0)
#endif
        {
            // pitch or roll
            VectorMA(org, scale, model->rotatedmins, ent->mins);
            VectorMA(org, scale, model->rotatedmaxs, ent->maxs);
        }
#ifdef MATRIX4x4_OPENGLORIENTATION
        else if (ent->matrix.m[1][0] != 0 || ent->matrix.m[0][1] != 0)
#else
        else if (ent->matrix.m[0][1] != 0 || ent->matrix.m[1][0] != 0)
#endif
        {
            // yaw
            VectorMA(org, scale, model->yawmins, ent->mins);
            VectorMA(org, scale, model->yawmaxs, ent->maxs);
        }
        else
        {
            VectorMA(org, scale, model->normalmins, ent->mins);
            VectorMA(org, scale, model->normalmaxs, ent->maxs);
        }
    }
    else
    {
        ent->mins[0] = org[0] - 16;
        ent->mins[1] = org[1] - 16;
        ent->mins[2] = org[2] - 16;
        ent->maxs[0] = org[0] + 16;
        ent->maxs[1] = org[1] + 16;
        ent->maxs[2] = org[2] + 16;
    }
}

References cl, entity_render_t::frameblend, entity_render_t::framegroupblend, entity_render_t::inversematrix, matrix4x4_t::m, entity_render_t::matrix, Matrix4x4_Invert_Simple(), Matrix4x4_OriginFromMatrix(), Matrix4x4_ScaleFromMatrix(), entity_render_t::maxs, entity_render_t::mins, entity_render_t::model, model, entity_render_t::scale, scale, client_state_t::time, VectorMA, and VM_FrameBlendFromFrameGroupBlend().

Referenced by CL_AddQWCTFFlagModel(), CL_ClearState(), CL_MeshEntities_Init(), CL_ParseStatic(), CL_RelinkBeams(), CL_RelinkEffects(), CL_RelinkQWNails(), CL_RelinkStaticEntities(), CL_RelinkWorld(), CL_SetupWorldModel(), CL_UpdateNetworkEntity(), CSQC_AddRenderEdict(), and VM_CL_makestatic().

◆ CL_UpdateViewEntities()

void CL_UpdateViewEntities ( void )

Definition at line 1432 of file cl_main.c.

{
    int i;
    // update any RENDER_VIEWMODEL entities to use the new view matrix
    for (i = 1;i < cl.num_entities;i++)
    {
        if (cl.entities_active[i])
        {
            entity_t *ent = cl.entities + i;
            if ((ent->render.flags & RENDER_VIEWMODEL) || ent->state_current.tagentity)
                CL_UpdateNetworkEntity(ent, 32, true);
        }
    }
    // and of course the engine viewmodel needs updating as well
    CL_UpdateNetworkEntity(&cl.viewent, 32, true);
}

References cl, CL_UpdateNetworkEntity(), client_state_t::entities, client_state_t::entities_active, entity_render_t::flags, i, client_state_t::num_entities, entity_t::render, RENDER_VIEWMODEL, entity_t::state_current, entity_state_t::tagentity, and client_state_t::viewent.

Referenced by VM_CL_R_RenderScene().

◆ CL_UpdateWorld()

void CL_UpdateWorld ( void )

Definition at line 2052 of file cl_main.c.

{
    r_refdef.scene.numentities = 0;
    r_refdef.scene.numlights = 0;
    r_refdef.view.matrix = identitymatrix;
    r_refdef.view.quality = 1;
        
    cl.num_brushmodel_entities = 0;
 
    if (cls.state == ca_connected && cls.signon == SIGNONS)
    {
        // prepare for a new frame
        CL_LerpPlayer(CL_LerpPoint());
        CL_DecayLightFlashes();
        CL_ClearTempEntities();
        V_DriftPitch();
        V_FadeViewFlashs();
 
        // if prediction is enabled we have to update all the collidable
        // network entities before the prediction code can be run
        CL_UpdateNetworkCollisionEntities();
 
        // now update the player prediction
        CL_ClientMovement_Replay();
 
        // update the player entity (which may be predicted)
        CL_UpdateNetworkEntity(cl.entities + cl.viewentity, 32, true);
 
        // now update the view (which depends on that player entity)
        V_CalcRefdef();
 
        // now update all the network entities and create particle trails
        // (some entities may depend on the view)
        CL_UpdateNetworkEntities();
 
        // update the engine-based viewmodel
        CL_UpdateViewModel();
 
        // when csqc is loaded, it will call this in CSQC_UpdateView
        if (!CLVM_prog->loaded || CLVM_prog->flag & PRVM_CSQC_SIMPLE)
        {
            // clear the CL_Mesh_Scene() used for some engine effects
            CL_MeshEntities_Scene_Clear();
            // add engine entities and effects
            CSQC_RelinkAllEntities(ENTMASK_ENGINE | ENTMASK_ENGINEVIEWMODELS);
        }
 
        // decals, particles, and explosions will be updated during rneder
    }
 
    r_refdef.scene.time = cl.time;
}

References ca_connected, cl, CL_ClearTempEntities(), CL_ClientMovement_Replay(), CL_DecayLightFlashes(), CL_LerpPlayer(), CL_LerpPoint(), CL_MeshEntities_Scene_Clear(), CL_UpdateNetworkCollisionEntities(), CL_UpdateNetworkEntities(), CL_UpdateNetworkEntity(), CL_UpdateViewModel(), cls, CLVM_prog, CSQC_RelinkAllEntities(), client_state_t::entities, ENTMASK_ENGINE, ENTMASK_ENGINEVIEWMODELS, identitymatrix, r_refdef_view_t::matrix, client_state_t::num_brushmodel_entities, r_refdef_scene_t::numentities, r_refdef_scene_t::numlights, PRVM_CSQC_SIMPLE, r_refdef_view_t::quality, r_refdef, r_refdef_t::scene, client_static_t::signon, SIGNONS, client_static_t::state, client_state_t::time, r_refdef_scene_t::time, V_CalcRefdef(), V_DriftPitch(), V_FadeViewFlashs(), r_refdef_t::view, and client_state_t::viewentity.

Referenced by CL_Frame().

◆ CL_ValidateState()

void CL_ValidateState ( entity_state_t * s )

Definition at line 1962 of file cl_parse.c.

{
    model_t *model;
 
    if (!s->active)
        return;
 
    if (s->modelindex >= MAX_MODELS)
        Host_Error("CL_ValidateState: modelindex (%i) >= MAX_MODELS (%i)\n", s->modelindex, MAX_MODELS);
 
    // these warnings are only warnings, no corrections are made to the state
    // because states are often copied for decoding, which otherwise would
    // propogate some of the corrections accidentally
    // (this used to happen, sometimes affecting skin and frame)
 
    // colormap is client index + 1
    if (!(s->flags & RENDER_COLORMAPPED) && s->colormap > cl.maxclients)
        Con_DPrintf("CL_ValidateState: colormap (%i) > cl.maxclients (%i)\n", s->colormap, cl.maxclients);
 
    if (developer_extra.integer)
    {
        model = CL_GetModelByIndex(s->modelindex);
        if (model && model->type && s->frame >= model->numframes)
            Con_DPrintf("CL_ValidateState: no such frame %i in \"%s\" (which has %i frames)\n", s->frame, model->name, model->numframes);
        if (model && model->type && s->skin > 0 && s->skin >= model->numskins && !(s->lightpflags & PFLAGS_FULLDYNAMIC))
            Con_DPrintf("CL_ValidateState: no such skin %i in \"%s\" (which has %i skins)\n", s->skin, model->name, model->numskins);
    }
}

References entity_state_t::active, cl, CL_GetModelByIndex(), entity_state_t::colormap, Con_DPrintf(), developer_extra, entity_state_t::flags, entity_state_t::frame, Host_Error(), cvar_t::integer, entity_state_t::lightpflags, MAX_MODELS, client_state_t::maxclients, model, entity_state_t::modelindex, PFLAGS_FULLDYNAMIC, RENDER_COLORMAPPED, and entity_state_t::skin.

◆ CL_WriteDemoMessage()

void CL_WriteDemoMessage ( sizebuf_t * mesage )

Definition at line 110 of file cl_demo.c.

{
    int     len;
    int     i;
    float   f;
 
    if (cls.demopaused) // LadyHavoc: pausedemo
        return;
 
    len = LittleLong (message->cursize);
    FS_Write (cls.demofile, &len, 4);
    for (i=0 ; i<3 ; i++)
    {
        f = LittleFloat (cl.viewangles[i]);
        FS_Write (cls.demofile, &f, 4);
    }
    FS_Write (cls.demofile, message->data, message->cursize);
}

References cl, cls, client_static_t::demofile, client_static_t::demopaused, f, FS_Write(), i, LittleFloat, LittleLong, message, and client_state_t::viewangles.

Referenced by CL_ParseServerMessage(), CL_Stop_f(), and CL_VM_Init().

◆ CL_WriteToServer()

void CL_WriteToServer ( void )

Variable Documentation

◆ cl

client_state_t cl

extern

Definition at line 117 of file cl_main.c.

◆ cl_anglespeedkey

cvar_t cl_anglespeedkey

extern

Definition at line 375 of file cl_input.c.

375{CF_CLIENT | CF_ARCHIVE, "cl_anglespeedkey","1.5","how much +speed multiplies keyboard turning speed"};

CF_ARCHIVE

#define CF_ARCHIVE

cvar should have its set value saved to config.cfg and persist across sessions

Definition cmd.h:53

Referenced by CL_AdjustAngles(), and CL_Init().

◆ cl_areagrid_link_SOLID_NOT

cvar_t cl_areagrid_link_SOLID_NOT

extern

Definition at line 112 of file cl_main.c.

112{CF_CLIENT, "cl_areagrid_link_SOLID_NOT", "1", "set to 0 to prevent SOLID_NOT entities from being linked to the area grid, and unlink any that are already linked (in the code paths that would otherwise link them), for better performance"};

Referenced by CL_Init(), and CL_LinkEdict().

◆ cl_autodemo

cvar_t cl_autodemo

extern

Definition at line 62 of file cl_main.c.

62{CF_CLIENT | CF_ARCHIVE, "cl_autodemo", "0", "records every game played, using the date/time and map name to name the demo file" };

Referenced by CL_Demo_Init(), CL_ParseServerInfo(), and CL_Stop_f().

◆ cl_autodemo_delete

cvar_t cl_autodemo_delete

extern

Definition at line 64 of file cl_main.c.

64{CF_CLIENT, "cl_autodemo_delete", "0", "3: automatically delete every newly recorded demo unless this cvar is set to 2 during a game, in case something interesting happened (cvar will be automatically set back to 3); 0: keep every newly recorded demo unless this cvar is set to 1 during a game, in case nothing interesting happened (cvar will be automatically set back to 0). Technically speaking, the value is a bitmask: bit 1 defines behaviour for all demos, bit 0 overrides behaviour for the demo currently being recorded" };

Referenced by CL_Demo_Init(), CL_ParseServerInfo(), and CL_Stop_f().

◆ cl_autodemo_nameformat

cvar_t cl_autodemo_nameformat

extern

Definition at line 63 of file cl_main.c.

63{CF_CLIENT | CF_ARCHIVE, "cl_autodemo_nameformat", "autodemos/%Y-%m-%d_%H-%M", "The format of the cl_autodemo filename, followed by the map name (the date is encoded using strftime escapes)" };

Referenced by CL_Demo_Init(), and CL_ParseServerInfo().

◆ cl_autofire

cvar_t cl_autofire

extern

◆ cl_backspeed

cvar_t cl_backspeed

extern

Definition at line 366 of file cl_input.c.

366{CF_CLIENT | CF_ARCHIVE, "cl_backspeed","400","backward movement speed"};

Referenced by CL_Init(), CL_Input(), and M_Menu_Options_AdjustSliders().

◆ cl_color

cvar_t cl_color

extern

Definition at line 252 of file cl_cmd.c.

252{CF_CLIENT | CF_ARCHIVE, "_cl_color", "0", "internal storage cvar for current player colors (changed by color command)"};

Referenced by CL_Bottomcolor_c(), CL_InitCommands(), and CL_Topcolor_c().

◆ cl_explosions_alpha_end

cvar_t cl_explosions_alpha_end

extern

Definition at line 70 of file cl_main.c.

70{CF_CLIENT | CF_ARCHIVE, "cl_explosions_alpha_end", "0","end alpha of an explosion shell (just before it disappears)"};

Referenced by CL_Init(), and R_NewExplosion().

◆ cl_explosions_alpha_start

cvar_t cl_explosions_alpha_start

extern

Definition at line 69 of file cl_main.c.

69{CF_CLIENT | CF_ARCHIVE, "cl_explosions_alpha_start", "1.5","starting alpha of an explosion shell"};

Referenced by CL_Init(), and R_NewExplosion().

◆ cl_explosions_lifetime

cvar_t cl_explosions_lifetime

extern

Definition at line 73 of file cl_main.c.

73{CF_CLIENT | CF_ARCHIVE, "cl_explosions_lifetime", "0.5","how long an explosion shell lasts"};

Referenced by CL_Init(), and R_NewExplosion().

◆ cl_explosions_size_end

cvar_t cl_explosions_size_end

extern

Definition at line 72 of file cl_main.c.

72{CF_CLIENT | CF_ARCHIVE, "cl_explosions_size_end", "128","ending alpha of an explosion shell (just before it disappears)"};

Referenced by CL_Init(), and R_NewExplosion().

◆ cl_explosions_size_start

cvar_t cl_explosions_size_start

extern

Definition at line 71 of file cl_main.c.

71{CF_CLIENT | CF_ARCHIVE, "cl_explosions_size_start", "16","starting size of an explosion shell"};

Referenced by CL_Init(), and R_NewExplosion().

◆ cl_forwardspeed

cvar_t cl_forwardspeed

extern

Definition at line 365 of file cl_input.c.

365{CF_CLIENT | CF_ARCHIVE, "cl_forwardspeed","400","forward movement speed"};

Referenced by CL_Init(), CL_Input(), IN_Move_TouchScreen_Quake(), IN_Move_TouchScreen_SteelStorm(), M_Menu_Options_AdjustSliders(), M_Options_Draw(), V_DriftPitch(), and VID_ApplyJoyState().

◆ cl_ignoremousemoves

int cl_ignoremousemoves

extern

Definition at line 474 of file cl_input.c.

Referenced by CL_Input(), VID_Mode(), VID_SetMouse(), and VM_CL_setcursormode().

◆ cl_locs_enable

cvar_t cl_locs_enable

extern

Definition at line 97 of file cl_main.c.

97{CF_CLIENT | CF_ARCHIVE, "locs_enable", "1", "enables replacement of certain % codes in chat messages: %l (location), %d (last death location), %h (health), %a (armor), %x (rockets), %c (cells), %r (rocket launcher status), %p (powerup status), %w (weapon status), %t (current time in level)"};

Referenced by CL_ForwardToServer(), and CL_Init().

◆ cl_meshentities

entity_t cl_meshentities[NUM_MESHENTITIES]

extern

Definition at line 2513 of file cl_main.c.

Referenced by CL_MeshEntities_Init(), CL_MeshEntities_Restart(), CL_MeshEntities_Scene_AddRenderEntity(), CL_MeshEntities_Scene_FinalizeRenderEntity(), CL_MeshEntities_Shutdown(), CL_MeshEntities_Start(), DrawQ_FlushUI(), and R_GetCurrentTexture().

◆ cl_meshentitymodels

model_t cl_meshentitymodels[NUM_MESHENTITIES]

extern

Definition at line 2514 of file cl_main.c.

Referenced by CL_MeshEntities_Init().

◆ cl_meshentitynames

const char* cl_meshentitynames[NUM_MESHENTITIES]

extern

Definition at line 2515 of file cl_main.c.

{
    "MESH_SCENE",
    "MESH_UI",
};

Referenced by CL_MeshEntities_Init(), CL_MeshEntities_Restart(), and CL_MeshEntities_Start().

◆ cl_movespeedkey

cvar_t cl_movespeedkey

extern

Definition at line 369 of file cl_input.c.

369{CF_CLIENT | CF_ARCHIVE, "cl_movespeedkey","2.0","how much +speed multiplies keyboard movement speed"};

Referenced by CL_Init(), and CL_Input().

◆ cl_name

cvar_t cl_name

extern

User-visible names of these CF_USERINFO cvars must be matched in CL_SetInfo()!

Definition at line 32 of file cl_cmd.c.

32{CF_CLIENT | CF_ARCHIVE | CF_USERINFO, "_cl_name", "player", "player name"};

CF_USERINFO

#define CF_USERINFO

command or cvar used to communicate userinfo to the server

Definition cmd.h:57

Referenced by CL_InitCommands(), CL_Name_f(), CL_SendPlayerInfo(), M_Menu_Setup_f(), M_Setup_Key(), and SV_Kick_f().

◆ cl_nettimesyncboundmode

cvar_t cl_nettimesyncboundmode

extern

Definition at line 192 of file cl_parse.c.

192{CF_CLIENT | CF_ARCHIVE, "cl_nettimesyncboundmode", "6", "method of restricting client time to valid values, 0 = no correction, 1 = tight bounding (jerky with packet loss), 2 = loose bounding (corrects it if out of bounds), 3 = leniant bounding (ignores temporary errors due to varying framerate), 4 = slow adjustment method from Quake3, 5 = slightly nicer version of Quake3 method, 6 = tight bounding + mode 5, 7 = jitter compensated dynamic adjustment rate"};

Referenced by CL_LerpPoint(), CL_NetworkTimeReceived(), and CL_Parse_Init().

◆ cl_nettimesyncboundtolerance

cvar_t cl_nettimesyncboundtolerance

extern

Definition at line 193 of file cl_parse.c.

193{CF_CLIENT | CF_ARCHIVE, "cl_nettimesyncboundtolerance", "0.25", "how much error is tolerated by bounding check, as a fraction of frametime, 0.25 = up to 25% margin of error tolerated, 1 = use only new time, 0 = use only old time (same effect as setting cl_nettimesyncfactor to 1) (only affects bound modes 2 and 3)"};

Referenced by CL_NetworkTimeReceived(), and CL_Parse_Init().

◆ cl_nettimesyncfactor

cvar_t cl_nettimesyncfactor

extern

Definition at line 191 of file cl_parse.c.

191{CF_CLIENT | CF_ARCHIVE, "cl_nettimesyncfactor", "0", "rate at which client time adapts to match server time, 1 = instantly, 0.125 = slowly, 0 = not at all (only applied in bound modes 0, 1, 2, 3)"};

Referenced by CL_NetworkTimeReceived(), and CL_Parse_Init().

◆ cl_pitchdriftspeed

cvar_t cl_pitchdriftspeed

extern

◆ cl_pitchspeed

cvar_t cl_pitchspeed

extern

Definition at line 373 of file cl_input.c.

373{CF_CLIENT | CF_ARCHIVE, "cl_pitchspeed","150","keyboard pitch turning speed"};

Referenced by CL_AdjustAngles(), CL_Init(), IN_Move_TouchScreen_Quake(), IN_Move_TouchScreen_SteelStorm(), and VID_ApplyJoyState().

◆ cl_playermodel

cvar_t cl_playermodel

extern

Definition at line 36 of file common.c.

36{CF_CLIENT | CF_SERVER | CF_USERINFO | CF_ARCHIVE, "playermodel", "", "current player model in Nexuiz/Xonotic"};

Referenced by CL_SendPlayerInfo(), and COM_Init_Commands().

◆ cl_playerskin

cvar_t cl_playerskin

extern

Definition at line 37 of file common.c.

37{CF_CLIENT | CF_SERVER | CF_USERINFO | CF_ARCHIVE, "playerskin", "", "current player skin in Nexuiz/Xonotic"};

Referenced by CL_SendPlayerInfo(), and COM_Init_Commands().

◆ cl_pmodel

cvar_t cl_pmodel

extern

Definition at line 40 of file cl_cmd.c.

40{CF_CLIENT | CF_USERINFO | CF_ARCHIVE, "pmodel", "0", "current player model number in nehahra"};

Referenced by CL_InitCommands(), and CL_SendPlayerInfo().

◆ cl_prydoncursor

cvar_t cl_prydoncursor

extern

Definition at line 92 of file cl_main.c.

92{CF_CLIENT, "cl_prydoncursor", "0", "enables a mouse pointer which is able to click on entities in the world, useful for point and click mods, see PRYDON_CLIENTCURSOR extension in dpextensions.qc"};

Referenced by CL_Init(), CL_Input(), CL_SendMove(), CL_UpdatePrydonCursor(), Sbar_Draw(), and Sys_SDL_HandleEvents().

◆ cl_prydoncursor_notrace

cvar_t cl_prydoncursor_notrace

extern

Definition at line 93 of file cl_main.c.

93{CF_CLIENT, "cl_prydoncursor_notrace", "0", "disables traceline used in prydon cursor reporting to the game, saving some cpu time"};

Referenced by CL_Init(), and CL_UpdatePrydonCursor().

◆ cl_rate

cvar_t cl_rate

extern

Definition at line 33 of file cl_cmd.c.

33{CF_CLIENT | CF_ARCHIVE | CF_USERINFO, "rate", "20000", "connection speed"};

Referenced by CL_InitCommands(), CL_SendMove(), CL_SendPlayerInfo(), M_Menu_Setup_f(), NetConn_ReceivedMessage(), and SCR_DrawNetGraph().

◆ cl_rate_burstsize

cvar_t cl_rate_burstsize

extern

Definition at line 34 of file cl_cmd.c.

34{CF_CLIENT | CF_ARCHIVE | CF_USERINFO, "rate_burstsize", "1024", "rate control burst size"};

Referenced by CL_InitCommands(), CL_SendMove(), CL_SendPlayerInfo(), and NetConn_ReceivedMessage().

◆ cl_shownet

cvar_t cl_shownet

extern

Definition at line 42 of file cl_main.c.

42{CF_CLIENT, "cl_shownet","0","1 = print packet size, 2 = print packet message list"};

Referenced by CL_Init(), and CL_ParseServerMessage().

◆ cl_sidespeed

cvar_t cl_sidespeed

extern

Definition at line 367 of file cl_input.c.

367{CF_CLIENT | CF_ARCHIVE, "cl_sidespeed","350","strafe movement speed"};

Referenced by CL_Init(), CL_Input(), IN_Move_TouchScreen_Quake(), IN_Move_TouchScreen_SteelStorm(), and VID_ApplyJoyState().

◆ cl_stainmaps

cvar_t cl_stainmaps

extern

Definition at line 75 of file cl_main.c.

75{CF_CLIENT | CF_ARCHIVE, "cl_stainmaps", "0","stains lightmaps, much faster than decals but blurred"};

◆ cl_stainmaps_clearonload

cvar_t cl_stainmaps_clearonload

extern

Definition at line 76 of file cl_main.c.

76{CF_CLIENT | CF_ARCHIVE, "cl_stainmaps_clearonload", "1","clear stainmaps on map restart"};

◆ cl_startdemos

cvar_t cl_startdemos

extern

Definition at line 65 of file cl_main.c.

65{CF_CLIENT | CF_ARCHIVE, "cl_startdemos", "1", "1 enables the `startdemos` loop used in Quake and some mods, 0 goes straight to the menu"};

Referenced by CL_Demo_Init(), and CL_Startdemos_f().

◆ cl_upspeed

cvar_t cl_upspeed

extern

Definition at line 364 of file cl_input.c.

364{CF_CLIENT | CF_ARCHIVE, "cl_upspeed","400","vertical movement speed (while swimming or flying)"};

Referenced by CL_Init(), CL_Input(), and VID_ApplyJoyState().

◆ cl_yawspeed

cvar_t cl_yawspeed

extern

Definition at line 372 of file cl_input.c.

372{CF_CLIENT | CF_ARCHIVE, "cl_yawspeed","140","keyboard yaw turning speed"};

Referenced by CL_AdjustAngles(), CL_Init(), IN_Move_TouchScreen_Quake(), IN_Move_TouchScreen_SteelStorm(), and VID_ApplyJoyState().

◆ cls

client_static_t cls

extern

Definition at line 116 of file cl_main.c.

◆ freelook

cvar_t freelook

extern

Definition at line 60 of file cl_main.c.

60{CF_CLIENT | CF_ARCHIVE, "freelook", "1","mouse controls pitch instead of forward/back"};

Referenced by CL_Init(), and CL_Input().

◆ in_klook

kbutton_t in_klook

Definition at line 1250 of file client.h.

◆ in_mlook

kbutton_t in_mlook

extern

Definition at line 51 of file cl_input.c.

Referenced by CL_Input(), IN_MLookDown(), and IN_MLookUp().

◆ in_speed

kbutton_t in_speed

extern

Definition at line 54 of file cl_input.c.

Referenced by CL_AdjustAngles(), CL_Input(), IN_SpeedDown(), and IN_SpeedUp().

◆ in_strafe

kbutton_t in_strafe

extern

Definition at line 54 of file cl_input.c.

Referenced by CL_AdjustAngles(), CL_Input(), IN_StrafeDown(), and IN_StrafeUp().

◆ lookspring

cvar_t lookspring

extern

Definition at line 51 of file cl_main.c.

51{CF_CLIENT | CF_ARCHIVE, "lookspring","0","returns pitch to level with the floor when no longer holding a pitch key"};

Referenced by CL_Init(), and IN_MLookUp().

◆ lookstrafe

cvar_t lookstrafe

extern

Definition at line 52 of file cl_main.c.

52{CF_CLIENT | CF_ARCHIVE, "lookstrafe","0","move instead of turning"};

Referenced by CL_Init(), and CL_Input().

◆ m_forward

cvar_t m_forward

extern

Definition at line 57 of file cl_main.c.

57{CF_CLIENT | CF_ARCHIVE, "m_forward","1","mouse forward speed multiplier"};

Referenced by CL_Init(), and CL_Input().

◆ m_pitch

cvar_t m_pitch

extern

Definition at line 55 of file cl_main.c.

55{CF_CLIENT | CF_ARCHIVE, "m_pitch","0.022","mouse pitch speed multiplier"};

Referenced by CL_Init(), CL_Input(), M_Menu_Options_AdjustSliders(), and M_Options_Draw().

◆ m_side

cvar_t m_side

extern

Definition at line 58 of file cl_main.c.

58{CF_CLIENT | CF_ARCHIVE, "m_side","0.8","mouse side speed multiplier"};

Referenced by CL_Init(), and CL_Input().

◆ m_yaw

cvar_t m_yaw

extern

Definition at line 56 of file cl_main.c.

56{CF_CLIENT | CF_ARCHIVE, "m_yaw","0.022","mouse yaw speed multiplier"};

Referenced by CL_Init(), and CL_Input().

◆ r_draweffects

cvar_t r_draweffects

extern

Definition at line 67 of file cl_main.c.

67{CF_CLIENT, "r_draweffects", "1","renders temporary sprite effects"};

Referenced by CL_Init(), and CL_RelinkEffects().

◆ rcon_address

cvar_t rcon_address

extern

Definition at line 92 of file console.c.

92{CF_CLIENT, "rcon_address", "", "server address to send rcon commands to (when not connected to a server)"};

Referenced by CL_PQRcon_f(), CL_Rcon_f(), and Con_Init().

◆ rcon_password

cvar_t rcon_password

extern

Definition at line 89 of file console.c.

89{CF_CLIENT | CF_SERVER | CF_PRIVATE, "rcon_password", "", "password to authenticate rcon commands; NOTE: changing rcon_secure clears rcon_password, so set rcon_secure always before rcon_password; may be set to a string of the form user1:pass1 user2:pass2 user3:pass3 to allow multiple user accounts - the client then has to specify ONE of these combinations"};

CF_PRIVATE

#define CF_PRIVATE

cvar should not be $ expanded or sent to the server under any circumstances (rcon_password,...

Definition cmd.h:59

Referenced by CL_Connect_f(), CL_PQRcon_f(), CL_Rcon_f(), Con_Init(), Con_RCon_ClearPassword_c(), NetConn_ClientParsePacket(), and RCon_Authenticate().

◆ sb_showscores

qbool sb_showscores

extern

Definition at line 56 of file sbar.c.

Referenced by CL_VM_DrawHud(), CL_VM_UpdateShowingScoresState(), Sbar_DontShowScores_f(), Sbar_Draw(), Sbar_ShowScores_f(), and SCR_DrawCenterString().

◆ sensitivity

cvar_t sensitivity

extern

Definition at line 53 of file cl_main.c.

53{CF_CLIENT | CF_ARCHIVE, "sensitivity","3","mouse speed multiplier"};

Referenced by CL_Init(), CL_Input(), M_Menu_Options_AdjustSliders(), and M_Options_Draw().

Data Structures

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ CL_MAX_DOWNLOADACKS

◆ CL_Mesh_Scene

◆ CL_Mesh_UI

◆ CSHIFT_BONUS

◆ CSHIFT_CONTENTS

◆ CSHIFT_DAMAGE

◆ CSHIFT_POWERUP

◆ CSHIFT_VCSHIFT

◆ LATESTFRAMENUMS

◆ LIGHTFLAG_NORMALMODE

◆ LIGHTFLAG_REALTIMEMODE

◆ MAX_FRAMEBLENDS

◆ MAX_RCONS

◆ NAME_LENGTH

◆ NUM_CSHIFTS

◆ NUM_TS_ERRORS

◆ SIGNONS

Enumeration Type Documentation

◆ cactive_t

◆ cl_parsingtextmode_t

◆ meshname_t

◆ qw_downloadtype_t

◆ waterlevel_t

Function Documentation

◆ CL_AllocLightFlash()

◆ CL_Beam_AddPolygons()

◆ CL_Beam_CalculatePositions()

◆ CL_ClearState()

◆ CL_ClearTempEntities()

◆ CL_ClientMovement_PlayerMove_Frame()

◆ CL_ClientMovement_Replay()

◆ CL_CutDemo()

◆ CL_Demo_Init()

◆ CL_Disconnect()

◆ CL_Disconnect_f()

◆ CL_DisconnectEx()

◆ CL_Effect()

◆ CL_EstablishConnection()

◆ CL_ExpandCSQCRenderEntities()

◆ CL_ExpandEntities()

◆ CL_FindNonSolidLocation()

◆ CL_ForwardToServer()

◆ CL_ForwardToServer_f()

◆ CL_Frame()

◆ CL_Init()

◆ CL_InitCommands()

◆ CL_InitInput()

◆ CL_Input()

◆ CL_KeyState()

◆ CL_LerpUpdate()

◆ CL_Locs_FindLocationName()

◆ CL_Locs_FindNearest()

◆ CL_Locs_Reload_f()

◆ CL_MeshEntities_Init()

◆ CL_MeshEntities_Scene_AddRenderEntity()

◆ CL_MeshEntities_Scene_Clear()

◆ CL_MeshEntities_Scene_FinalizeRenderEntity()

◆ CL_MoveLerpEntityStates()

◆ CL_NewBeam()

◆ CL_NewFrameReceived()

◆ CL_NewTempEntity()

◆ CL_NextDemo()

◆ CL_ParseEntityLump()

◆ CL_ParseTEnt()

◆ CL_PasteDemo()

◆ CL_PlayDemo()

◆ CL_PlayDemo_f()

◆ CL_ReadDemoMessage()

◆ CL_Record_f()

◆ CL_RelinkBeams()

◆ CL_RelinkLightFlashes()

◆ CL_RotateMoves()

◆ CL_SendMove()

◆ CL_SetEntityColormapColors()