X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=client.h;h=6e73a042113be1b21d54012b3e9405e900fc8696;hp=7ded7895bd79fd30b5eb59627ff4c3355a186099;hb=7a96ec58916ceea50684acf4c00eaef551199fef;hpb=da1866f3c048815988f5986896f72d3c29d749f4

diff --git a/client.h b/client.h
index 7ded7895..6e73a042 100644
--- a/client.h
+++ b/client.h
@@ -27,6 +27,9 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 // LordHavoc: 256 dynamic lights
 #define MAX_DLIGHTS 256
 
+// this is the maximum number of input packets that can be predicted
+#define CL_MAX_USERCMDS 256
+
 // flags for rtlight rendering
 #define LIGHTFLAG_NORMALMODE 1
 #define LIGHTFLAG_REALTIMEMODE 2
@@ -55,12 +58,6 @@ typedef struct beam_s
 	struct model_s	*model;
 	float	endtime;
 	vec3_t	start, end;
-	// if this beam is owned by an entity, this is the beam start relative to
-	// that entity's matrix for per frame start updates
-	vec3_t	relativestart;
-	vec3_t	relativeend;
-	// indicates whether relativestart is valid
-	int	relativestartvalid;
 }
 beam_t;
 
@@ -71,6 +68,8 @@ typedef struct rtlight_s
 	// note that the world to light matrices are inversely scaled (divided) by lightradius
 
 	// core properties
+	// matrix for transforming light filter coordinates to world coordinates
+	matrix4x4_t matrix_lighttoworld;
 	// matrix for transforming world coordinates to light filter coordinates
 	matrix4x4_t matrix_worldtolight;
 	// typically 1 1 1, can be lower (dim) or higher (overbright)
@@ -128,6 +127,19 @@ typedef struct rtlight_s
 	// surfaces seen by light
 	int static_numsurfaces;
 	int *static_surfacelist;
+	// flag bits indicating which triangles of the world model should cast
+	// shadows, and which ones should be lit
+	//
+	// this avoids redundantly scanning the triangles in each surface twice
+	// for whether they should cast shadows, once in culling and once in the
+	// actual shadowmarklist production.
+	int static_numshadowtrispvsbytes;
+	unsigned char *static_shadowtrispvs;
+	// this allows the lighting batch code to skip backfaces andother culled
+	// triangles not relevant for lighting
+	// (important on big surfaces such as terrain)
+	int static_numlighttrispvsbytes;
+	unsigned char *static_lighttrispvs;
 }
 rtlight_t;
 
@@ -152,11 +164,7 @@ typedef struct dlight_s
 	// color of light
 	// (worldlight: saved to .rtlights file)
 	vec3_t color;
-	// cubemap number to use on this light
-	// (dlight only)
-	int cubemapnum;
 	// cubemap name to use on this light
-	// (worldlight only)
 	// (worldlight: saved to .rtlights file)
 	char cubemapname[64];
 	// make light flash while selected
@@ -165,9 +173,16 @@ typedef struct dlight_s
 	// brightness (not really radius anymore)
 	// (worldlight: saved to .rtlights file)
 	vec_t radius;
-	// drop radius this much each second
+	// drop intensity this much each second
 	// (dlight only)
 	vec_t decay;
+	// intensity value which is dropped over time
+	// (dlight only)
+	vec_t intensity;
+	// initial values for intensity to modify
+	// (dlight only)
+	vec_t initialradius;
+	vec3_t initialcolor;
 	// light style which controls intensity of this light
 	// (worldlight: saved to .rtlights file)
 	int style;
@@ -196,7 +211,7 @@ typedef struct dlight_s
 	// (worldlight only)
 	struct dlight_s *next;
 	// embedded rtlight struct for renderer
-	// (renderer only)
+	// (worldlight only)
 	rtlight_t rtlight;
 }
 dlight_t;
@@ -210,12 +225,18 @@ frameblend_t;
 
 // LordHavoc: this struct is intended for the renderer but some fields are
 // used by the client.
+//
+// The renderer should not rely on any changes to this struct to be persistent
+// across multiple frames because temp entities are wiped every frame, but it
+// is acceptable to cache things in this struct that are not critical.
+//
+// For example the r_cullentities_trace code does such caching.
 typedef struct entity_render_s
 {
 	// location
-	vec3_t origin;
+	//vec3_t origin;
 	// orientation
-	vec3_t angles;
+	//vec3_t angles;
 	// transform matrix for model to world
 	matrix4x4_t matrix;
 	// transform matrix for world to model
@@ -226,16 +247,16 @@ typedef struct entity_render_s
 	float scale;
 
 	// NULL = no model
-	model_t *model;
-	// current uninterpolated animation frame (for things which do not use interpolation)
-	int frame;
-	// entity shirt and pants colors (-1 if not colormapped)
-	int colormap;
-	// literal colors for renderer
+	dp_model_t *model;
+	// number of the entity represents, or 0 for non-network entities
+	int entitynumber;
+	// literal colormap colors for renderer, if both are 0 0 0 it is not colormapped
 	vec3_t colormap_pantscolor;
 	vec3_t colormap_shirtcolor;
 	// light, particles, etc
 	int effects;
+	// qw CTF flags and other internal-use-only effect bits
+	int internaleffects;
 	// for Alias models
 	int skinnum;
 	// render flags
@@ -259,28 +280,29 @@ typedef struct entity_render_s
 
 	// calculated by the renderer (but not persistent)
 
-	// if visframe == r_framecount, it is visible
-	int visframe;
 	// calculated during R_AddModelEntities
 	vec3_t mins, maxs;
 	// 4 frame numbers (-1 if not used) and their blending scalers (0-1), if interpolation is not desired, use frame instead
 	frameblend_t frameblend[4];
 
-	// current lighting from map
+	// current lighting from map (updated ONLY by client code, not renderer)
 	vec3_t modellight_ambient;
 	vec3_t modellight_diffuse; // q3bsp
 	vec3_t modellight_lightdir; // q3bsp
+
+	// FIELDS UPDATED BY RENDERER:
+	// last time visible during trace culling
+	double last_trace_visibility;
 }
 entity_render_t;
 
 typedef struct entity_persistent_s
 {
-	int linkframe;
-
 	vec3_t trail_origin;
 
 	// particle trail
 	float trail_time;
+	qboolean trail_allowed; // set to false by teleports, true by update code, prevents bad lerps
 
 	// muzzleflash fading
 	float muzzleflash;
@@ -301,7 +323,6 @@ entity_persistent_t;
 
 typedef struct entity_s
 {
-	qboolean csqc;
 	// baseline state (default values)
 	entity_state_t state_baseline;
 	// previous state (interpolating from this)
@@ -334,12 +355,21 @@ typedef struct usercmd_s
 	vec_t	cursor_fraction;
 	int		cursor_entitynumber;
 
-	double time;
-	double receivetime;
+	double time; // time the move is executed for (cl_movement: clienttime, non-cl_movement: receivetime)
+	double receivetime; // time the move was received at
+	double clienttime; // time to which server state the move corresponds to
+	int msec; // for predicted moves
 	int buttons;
 	int impulse;
 	int sequence;
 	qboolean applied; // if false we're still accumulating a move
+	qboolean predicted; // if true the sequence should be sent as 0
+
+	// derived properties
+	double frametime;
+	qboolean canjump;
+	qboolean jump;
+	qboolean crouch;
 } usercmd_t;
 
 typedef struct lightstyle_s
@@ -391,6 +421,7 @@ typedef struct cshift_s
 
 typedef enum cactive_e
 {
+	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
@@ -409,13 +440,65 @@ qw_downloadtype_t;
 
 typedef enum capturevideoformat_e
 {
-	CAPTUREVIDEOFORMAT_TARGA,
-	CAPTUREVIDEOFORMAT_JPEG,
-	CAPTUREVIDEOFORMAT_RAWRGB,
-	CAPTUREVIDEOFORMAT_RAWYV12
+	CAPTUREVIDEOFORMAT_AVI_I420
 }
 capturevideoformat_t;
 
+typedef struct capturevideostate_s
+{
+	double starttime;
+	double framerate;
+	// for AVI saving some values have to be written after capture ends
+	fs_offset_t videofile_firstchunkframes_offset;
+	fs_offset_t videofile_totalframes_offset1;
+	fs_offset_t videofile_totalframes_offset2;
+	fs_offset_t videofile_totalsampleframes_offset;
+	int videofile_ix_master_audio_inuse;
+	fs_offset_t videofile_ix_master_audio_inuse_offset;
+	fs_offset_t videofile_ix_master_audio_start_offset;
+	int videofile_ix_master_video_inuse;
+	fs_offset_t videofile_ix_master_video_inuse_offset;
+	fs_offset_t videofile_ix_master_video_start_offset;
+	fs_offset_t videofile_ix_movistart;
+	qfile_t *videofile;
+	qboolean active;
+	qboolean realtime;
+	qboolean error;
+	capturevideoformat_t format;
+	int soundrate;
+	int frame;
+	int soundsampleframe; // for AVI saving
+	unsigned char *screenbuffer;
+	unsigned char *outbuffer;
+	sizebuf_t riffbuffer;
+	unsigned char riffbufferdata[128];
+	// note: riffindex buffer has an allocated ->data member, not static like most!
+	sizebuf_t riffindexbuffer;
+	int riffstacklevel;
+	fs_offset_t riffstackstartoffset[4];
+	short rgbtoyuvscaletable[3][3][256];
+	unsigned char yuvnormalizetable[3][256];
+	char basename[64];
+	int width, height;
+}
+capturevideostate_t;
+
+#define CL_MAX_DOWNLOADACKS 4
+
+typedef struct cl_downloadack_s
+{
+	int start, size;
+}
+cl_downloadack_t;
+
+typedef struct cl_soundstats_s
+{
+	int mixedsounds;
+	int totalsounds;
+	int latency_milliseconds;
+}
+cl_soundstats_t;
+
 //
 // the client_static_t structure is persistent through an arbitrary number
 // of server connections
@@ -444,19 +527,22 @@ typedef struct client_static_s
 	// -1 = use normal cd track
 	int forcetrack;
 	qfile_t *demofile;
-	// to meter out one message a frame
-	int td_lastframe;
-	// host_framecount at start
-	int td_startframe;
 	// realtime at second frame of timedemo (LordHavoc: changed to double)
 	double td_starttime;
-	// LordHavoc: for measuring maxfps
-	double td_minframetime;
-	// LordHavoc: for measuring minfps
-	double td_maxframetime;
+	int td_frames; // total frames parsed
+	double td_onesecondnexttime;
+	double td_onesecondframes;
+	double td_onesecondrealtime;
+	double td_onesecondminfps;
+	double td_onesecondmaxfps;
+	double td_onesecondavgfps;
+	int td_onesecondavgcount;
 	// LordHavoc: pausedemo
 	qboolean demopaused;
 
+	// sound mixer statistics for showsound display
+	cl_soundstats_t soundstats;
+
 	qboolean connect_trying;
 	int connect_remainingtries;
 	double connect_nextsendtime;
@@ -472,10 +558,21 @@ typedef struct client_static_s
 	// network connection
 	netconn_t *netcon;
 
+	// download information
+	// (note: qw_download variables are also used)
+	cl_downloadack_t dp_downloadack[CL_MAX_DOWNLOADACKS];
+
+	// input sequence numbers are not reset on level change, only connect
+	int movesequence;
+	int servermovesequence;
+
 	// quakeworld stuff below
 
 	// value of "qport" cvar at time of connection
 	int qw_qport;
+	// copied from cls.netcon->qw. variables every time they change, or set by demos (which have no cls.netcon)
+	int qw_incoming_sequence;
+	int qw_outgoing_sequence;
 
 	// current file download buffer (only saved when file is completed)
 	char qw_downloadname[MAX_QPATH];
@@ -485,6 +582,10 @@ typedef struct client_static_s
 	int qw_downloadnumber;
 	int qw_downloadpercent;
 	qw_downloadtype_t qw_downloadtype;
+	// transfer rate display
+	double qw_downloadspeedtime;
+	int qw_downloadspeedcount;
+	int qw_downloadspeedrate;
 
 	// current file upload buffer (for uploading screenshots to server)
 	unsigned char *qw_uploaddata;
@@ -497,17 +598,7 @@ typedef struct client_static_s
 	char userinfo[MAX_USERINFO_STRING];
 
 	// video capture stuff
-	qboolean capturevideo_active;
-	capturevideoformat_t capturevideo_format;
-	double capturevideo_starttime;
-	double capturevideo_framerate;
-	int capturevideo_soundrate;
-	int capturevideo_frame;
-	unsigned char *capturevideo_buffer;
-	qfile_t *capturevideo_videofile;
-	qfile_t *capturevideo_soundfile;
-	short capturevideo_rgbtoyuvscaletable[3][3][256];
-	unsigned char capturevideo_yuvnormalizetable[3][256];
+	capturevideostate_t capturevideo;
 }
 client_static_t;
 
@@ -522,6 +613,7 @@ typedef struct client_movementqueue_s
 	float move[3];
 	qboolean jump;
 	qboolean crouch;
+	qboolean canjump;
 }
 client_movementqueue_t;
 
@@ -533,18 +625,6 @@ typedef struct
 	qboolean drawcrosshair;
 }csqc_vidvars_t;
 
-typedef struct qw_usercmd_s
-{
-	vec3_t angles;
-	short forwardmove, sidemove, upmove;
-	unsigned char padding1[2];
-	unsigned char msec;
-	unsigned char buttons;
-	unsigned char impulse;
-	unsigned char padding2;
-}
-qw_usercmd_t;
-
 typedef enum
 {
 	PARTICLE_BILLBOARD = 0,
@@ -572,33 +652,85 @@ particletype_t;
 
 typedef enum
 {
-	pt_alphastatic, pt_static, pt_spark, pt_beam, pt_rain, pt_raindecal, pt_snow, pt_bubble, pt_blood, pt_smoke, pt_decal, pt_entityparticle, pt_total
+	pt_dead, pt_alphastatic, pt_static, pt_spark, pt_beam, pt_rain, pt_raindecal, pt_snow, pt_bubble, pt_blood, pt_smoke, pt_decal, pt_entityparticle, pt_total
 }
 ptype_t;
 
+typedef struct decal_s
+{
+	// fields used by rendering:  (40 bytes)
+	unsigned short	typeindex;
+	unsigned short	texnum;
+	vec3_t			org;
+	vec3_t			normal;
+	float			size;
+	float			alpha; // 0-255
+	unsigned char	color[3];
+	unsigned char	unused1;
+
+	// fields not used by rendering: (36 bytes in 32bit, 40 bytes in 64bit)
+	float			time2; // used for decal fade
+	unsigned int	owner; // decal stuck to this entity
+	dp_model_t			*ownermodel; // model the decal is stuck to (used to make sure the entity is still alive)
+	vec3_t			relativeorigin; // decal at this location in entity's coordinate space
+	vec3_t			relativenormal; // decal oriented this way relative to entity's coordinate space
+}
+decal_t;
+
 typedef struct particle_s
 {
-	particletype_t *type;
-	int			texnum;
-	vec3_t		org;
-	vec3_t		vel; // velocity of particle, or orientation of decal, or end point of beam
-	float		size;
-	float		sizeincrease; // rate of size change per second
-	float		alpha; // 0-255
-	float		alphafade; // how much alpha reduces per second
-	float		time2; // used for snow fluttering and decal fade
-	float		bounce; // how much bounce-back from a surface the particle hits (0 = no physics, 1 = stop and slide, 2 = keep bouncing forever, 1.5 is typical)
-	float		gravity; // how much gravity affects this particle (1.0 = normal gravity, 0.0 = none)
-	float		airfriction; // how much air friction affects this object (objects with a low mass/size ratio tend to get more air friction)
-	float		liquidfriction; // how much liquid friction affects this object (objects with a low mass/size ratio tend to get more liquid friction)
-	unsigned char		color[4];
-	unsigned short owner; // decal stuck to this entity
-	model_t		*ownermodel; // model the decal is stuck to (used to make sure the entity is still alive)
-	vec3_t		relativeorigin; // decal at this location in entity's coordinate space
-	vec3_t		relativedirection; // decal oriented this way relative to entity's coordinate space
+	// fields used by rendering: (40 bytes)
+	unsigned short	typeindex;
+	unsigned short	texnum;
+	vec3_t			org;
+	vec3_t			vel; // velocity of particle, or orientation of decal, or end point of beam
+	float			size;
+	float			alpha; // 0-255
+	unsigned char	color[3];
+	unsigned char	qualityreduction; // enables skipping of this particle according to r_refdef.view.qualityreduction
+
+	// fields not used by rendering:  (40 bytes)
+	float			sizeincrease; // rate of size change per second
+	float			alphafade; // how much alpha reduces per second
+	float			time2; // used for snow fluttering and decal fade
+	float			bounce; // how much bounce-back from a surface the particle hits (0 = no physics, 1 = stop and slide, 2 = keep bouncing forever, 1.5 is typical)
+	float			gravity; // how much gravity affects this particle (1.0 = normal gravity, 0.0 = none)
+	float			airfriction; // how much air friction affects this object (objects with a low mass/size ratio tend to get more air friction)
+	float			liquidfriction; // how much liquid friction affects this object (objects with a low mass/size ratio tend to get more liquid friction)
+	float			delayedcollisions; // time that p->bounce becomes active
+	float			delayedspawn; // time that particle appears and begins moving
+	float			die; // time when this particle should be removed, regardless of alpha
 }
 particle_t;
 
+typedef enum cl_parsingtextmode_e
+{
+	CL_PARSETEXTMODE_NONE,
+	CL_PARSETEXTMODE_PING,
+	CL_PARSETEXTMODE_STATUS,
+	CL_PARSETEXTMODE_STATUS_PLAYERID,
+	CL_PARSETEXTMODE_STATUS_PLAYERIP
+}
+cl_parsingtextmode_t;
+
+typedef struct cl_locnode_s
+{
+	struct cl_locnode_s *next;
+	char *name;
+	vec3_t mins, maxs;
+}
+cl_locnode_t;
+
+typedef struct showlmp_s
+{
+	qboolean	isactive;
+	float		x;
+	float		y;
+	char		label[32];
+	char		pic[128];
+}
+showlmp_t;
+
 //
 // the client_state_t structure is wiped completely at every
 // server signon
@@ -608,19 +740,18 @@ typedef struct client_state_s
 	// true if playing in a local game and no one else is connected
 	int islocalgame;
 
-	// when connecting to the server throw out the first couple move messages
-	// so the player doesn't accidentally do something the first frame
-	int movemessages;
-
 	// send a clc_nop periodically until connected
 	float sendnoptime;
 
-	// current input to send to the server
+	// current input being accumulated by mouse/joystick/etc input
 	usercmd_t cmd;
+	// latest moves sent to the server that have not been confirmed yet
+	usercmd_t movecmd[CL_MAX_USERCMDS];
 
 // information for local display
 	// health, etc
 	int stats[MAX_CL_STATS];
+	float *statsf; // points to stats[] array
 	// last known inventory bit flags, for blinking
 	int olditems;
 	// cl.time of acquiring item, for blinking
@@ -631,6 +762,9 @@ typedef struct client_state_s
 	float weapontime;
 	// use pain anim frame if cl.time < this
 	float faceanimtime;
+	// for stair smoothing
+	float stairsmoothz;
+	double stairsmoothtime;
 
 	// color shifts for damage, powerups
 	cshift_t cshifts[NUM_CSHIFTS];
@@ -662,21 +796,15 @@ typedef struct client_state_s
 
 	// client movement simulation
 	// these fields are only updated by CL_ClientMovement (called by CL_SendMove after parsing each network packet)
-	qboolean movement;
-	// this is set true by svc_time parsing and causes a new movement to be
-	// queued for prediction purposes
-	qboolean movement_needupdate;
-	// indicates the queue has been updated and should be replayed
+	// set by CL_ClientMovement_Replay functions
+	qboolean movement_predicted;
+	// if true the CL_ClientMovement_Replay function will update origin, etc
 	qboolean movement_replay;
 	// simulated data (this is valid even if cl.movement is false)
 	vec3_t movement_origin;
-	vec3_t movement_oldorigin;
 	vec3_t movement_velocity;
-	// queue of proposed moves
-	int movement_numqueue;
-	client_movementqueue_t movement_queue[64];
-	int movesequence;
-	int servermovesequence;
+	// whether the replay should allow a jump at the first sequence
+	qboolean movement_replay_canjump;
 
 // pitch drifting vars
 	float idealpitch;
@@ -715,6 +843,8 @@ typedef struct client_state_s
 	// clients view of time, time should be between mtime[0] and mtime[1] to
 	// generate a lerp point for other data, oldtime is the previous frame's
 	// value of time, frametime is the difference between time and oldtime
+	// note: cl.time may be beyond cl.mtime[0] if packet loss is occuring, it
+	// is only forcefully limited when a packet is received
 	double time, oldtime;
 	// how long it has been since the previous client frame in real time
 	// (not game time, for that use cl.time - cl.oldtime)
@@ -737,6 +867,11 @@ typedef struct client_state_s
 	int viewentity;
 	// the real player entity (normally same as viewentity,
 	// different than viewentity if mod uses chasecam or other tricks)
+	int realplayerentity;
+	// this is updated to match cl.viewentity whenever it is in the clients
+	// range, basically this is used in preference to cl.realplayerentity for
+	// most purposes because when spectating another player it should show
+	// their information rather than yours
 	int playerentity;
 	// max players that can be in this game
 	int maxclients;
@@ -744,10 +879,10 @@ typedef struct client_state_s
 	int gametype;
 
 	// models and sounds used by engine code (particularly cl_parse.c)
-	model_t *model_bolt;
-	model_t *model_bolt2;
-	model_t *model_bolt3;
-	model_t *model_beam;
+	dp_model_t *model_bolt;
+	dp_model_t *model_bolt2;
+	dp_model_t *model_bolt3;
+	dp_model_t *model_beam;
 	sfx_t *sfx_wizhit;
 	sfx_t *sfx_knighthit;
 	sfx_t *sfx_tink1;
@@ -755,6 +890,8 @@ typedef struct client_state_s
 	sfx_t *sfx_ric2;
 	sfx_t *sfx_ric3;
 	sfx_t *sfx_r_exp3;
+	// indicates that the file "sound/misc/talk2.wav" was found (for use by team chat messages)
+	qboolean foundtalk2wav;
 
 // refresh related state
 
@@ -772,6 +909,16 @@ typedef struct client_state_s
 	// [cl.maxclients]
 	scoreboard_t *scores;
 
+	// keep track of svc_print parsing state (analyzes ping reports and status reports)
+	cl_parsingtextmode_t parsingtextmode;
+	int parsingtextplayerindex;
+	// set by scoreboard code when sending ping command, this causes the next ping results to be hidden
+	// (which could eat the wrong ping report if the player issues one
+	//  manually, but they would still see a ping report, just a later one
+	//  caused by the scoreboard code rather than the one they intentionally
+	//  issued)
+	int parsingtextexpectingpingforscores;
+
 	// entity database stuff
 	// latest received entity frame numbers
 #define LATESTFRAMENUMS 3
@@ -791,40 +938,54 @@ typedef struct client_state_s
 	vec3_t playercrouchmaxs;
 
 	int max_entities;
-	int max_csqcentities;
 	int max_static_entities;
-	int max_temp_entities;
 	int max_effects;
 	int max_beams;
 	int max_dlights;
 	int max_lightstyle;
 	int max_brushmodel_entities;
 	int max_particles;
+	int max_decals;
+	int max_showlmps;
 
 	entity_t *entities;
-	entity_t *csqcentities;	//[515]: csqc
 	unsigned char *entities_active;
-	unsigned char *csqcentities_active;	//[515]: csqc
 	entity_t *static_entities;
-	entity_t *temp_entities;
 	cl_effect_t *effects;
 	beam_t *beams;
 	dlight_t *dlights;
 	lightstyle_t *lightstyle;
 	int *brushmodel_entities;
 	particle_t *particles;
+	decal_t *decals;
+	showlmp_t *showlmps;
 
 	int num_entities;
-	int num_csqcentities;	//[515]: csqc
 	int num_static_entities;
-	int num_temp_entities;
 	int num_brushmodel_entities;
 	int num_effects;
 	int num_beams;
 	int num_dlights;
 	int num_particles;
+	int num_decals;
+	int num_showlmps;
 
+	double particles_updatetime;
+	double decals_updatetime;
 	int free_particle;
+	int free_decal;
+
+	// cl_serverextension_download feature
+	int loadmodel_current;
+	int downloadmodel_current;
+	int loadmodel_total;
+	int loadsound_current;
+	int downloadsound_current;
+	int loadsound_total;
+	qboolean downloadcsqc;
+	qboolean loadcsqc;
+	qboolean loadbegun;
+	qboolean loadfinished;
 
 	// quakeworld stuff
 
@@ -840,20 +1001,32 @@ typedef struct client_state_s
 	// updated from serverinfo
 	int qw_teamplay;
 
-	// indicates whether the player is spectating
-	qboolean qw_spectator;
+	// unused: indicates whether the player is spectating
+	// use cl.scores[cl.playerentity-1].qw_spectator instead
+	//qboolean qw_spectator;
+
+	// last time an input packet was sent
+	double lastpackettime;
 
 	// movement parameters for client prediction
-	float qw_movevars_gravity;
-	float qw_movevars_stopspeed;
-	float qw_movevars_maxspeed; // can change during play
-	float qw_movevars_spectatormaxspeed;
-	float qw_movevars_accelerate;
-	float qw_movevars_airaccelerate;
-	float qw_movevars_wateraccelerate;
-	float qw_movevars_friction;
-	float qw_movevars_waterfriction;
-	float qw_movevars_entgravity; // can change during play
+	float movevars_wallfriction;
+	float movevars_waterfriction;
+	float movevars_friction;
+	float movevars_timescale;
+	float movevars_gravity;
+	float movevars_stopspeed;
+	float movevars_maxspeed;
+	float movevars_spectatormaxspeed;
+	float movevars_accelerate;
+	float movevars_airaccelerate;
+	float movevars_wateraccelerate;
+	float movevars_entgravity;
+	float movevars_jumpvelocity;
+	float movevars_edgefriction;
+	float movevars_maxairspeed;
+	float movevars_stepheight;
+	float movevars_airaccel_qw;
+	float movevars_airaccel_sideways_friction;
 
 	// models used by qw protocol
 	int qw_modelindex_spike;
@@ -872,9 +1045,31 @@ typedef struct client_state_s
 
 	int qw_validsequence;
 
-	qw_usercmd_t qw_moves[QW_UPDATE_BACKUP];
-
 	int qw_deltasequence[QW_UPDATE_BACKUP];
+
+	// csqc stuff:
+	// server entity number corresponding to a clientside entity
+	unsigned short csqc_server2csqcentitynumber[MAX_EDICTS];
+	qboolean csqc_loaded;
+	vec3_t csqc_origin;
+	vec3_t csqc_angles;
+	qboolean csqc_usecsqclistener;
+	matrix4x4_t csqc_listenermatrix;
+	char csqc_printtextbuf[MAX_INPUTLINE];
+
+	// collision culling data
+	world_t world;
+
+	// loc file stuff (points and boxes describing locations in the level)
+	cl_locnode_t *locnodes;
+	// this is updated to cl.movement_origin whenever health is < 1
+	// used by %d print in say/say_team messages if cl_locs_enable is on
+	vec3_t lastdeathorigin;
+
+	// processing buffer used by R_BuildLightMap, reallocated as needed,
+	// freed on each level change
+	size_t buildlightmapmemorysize;
+	unsigned char *buildlightmapmemory;
 }
 client_state_t;
 
@@ -905,11 +1100,11 @@ extern cvar_t cl_anglespeedkey;
 
 extern cvar_t cl_autofire;
 
-extern cvar_t csqc_progname;	//[515]: csqc crc check and right csprogs name according to progs.dat
-extern cvar_t csqc_progcrc;
-
 extern cvar_t cl_shownet;
 extern cvar_t cl_nolerp;
+extern cvar_t cl_nettimesyncfactor;
+extern cvar_t cl_nettimesyncboundmode;
+extern cvar_t cl_nettimesyncboundtolerance;
 
 extern cvar_t cl_pitchdriftspeed;
 extern cvar_t lookspring;
@@ -938,9 +1133,14 @@ extern cvar_t cl_stainmaps_clearonload;
 
 extern cvar_t cl_prydoncursor;
 
+extern cvar_t cl_locs_enable;
+
 extern client_state_t cl;
 
-extern void CL_AllocDlight (entity_render_t *ent, matrix4x4_t *matrix, float radius, float red, float green, float blue, float decay, float lifetime, int cubemapnum, int style, int shadowenable, vec_t corona, vec_t coronasizescale, vec_t ambientscale, vec_t diffusescale, vec_t specularscale, int flags);
+extern void CL_AllocLightFlash (entity_render_t *ent, matrix4x4_t *matrix, float radius, float red, float green, float blue, float decay, float lifetime, int cubemapnum, int style, int shadowenable, vec_t corona, vec_t coronasizescale, vec_t ambientscale, vec_t diffusescale, vec_t specularscale, int flags);
+
+cl_locnode_t *CL_Locs_FindNearest(const vec3_t point);
+void CL_Locs_FindLocationName(char *buffer, size_t buffersize, vec3_t point);
 
 //=============================================================================
 
@@ -956,11 +1156,9 @@ void CL_EstablishConnection(const char *host);
 void CL_Disconnect (void);
 void CL_Disconnect_f (void);
 
-void CL_BoundingBoxForEntity(entity_render_t *ent);
-
-extern cvar_t cl_beams_polygons;
-extern cvar_t cl_beams_relative;
-extern cvar_t cl_beams_lightatend;
+void CL_UpdateRenderEntity(entity_render_t *ent);
+void CL_SetEntityColormapColors(entity_render_t *ent, int colormap);
+void CL_UpdateViewEntities(void);
 
 //
 // cl_input
@@ -983,21 +1181,25 @@ void CL_ValidateState(entity_state_t *s);
 void CL_MoveLerpEntityStates(entity_t *ent);
 void CL_LerpUpdate(entity_t *e);
 void CL_ParseTEnt (void);
+void CL_NewBeam (int ent, vec3_t start, vec3_t end, dp_model_t *m, int lightning);
 void CL_RelinkBeams (void);
+void CL_Beam_CalculatePositions (const beam_t *b, vec3_t start, vec3_t end);
+void CL_ClientMovement_Replay(void);
 
 void CL_ClearTempEntities (void);
-entity_t *CL_NewTempEntity (void);
+entity_render_t *CL_NewTempEntity (void);
 
 void CL_Effect(vec3_t org, int modelindex, int startframe, int framecount, float framerate);
 
 void CL_ClearState (void);
 void CL_ExpandEntities(int num);
+void CL_SetInfo(const char *key, const char *value, qboolean send, qboolean allowstarkey, qboolean allowmodel, qboolean quiet);
 
 
-int  CL_ReadFromServer (void);
+void CL_UpdateWorld (void);
 void CL_WriteToServer (void);
-void CL_Move (void);
-extern qboolean cl_ignoremousemove;
+void CL_Input (void);
+extern int cl_ignoremousemoves;
 
 
 float CL_KeyState (kbutton_t *key);
@@ -1009,7 +1211,7 @@ int Key_StringToKeynum (const char *str);
 //
 void CL_StopPlayback(void);
 void CL_ReadDemoMessage(void);
-void CL_WriteDemoMessage(void);
+void CL_WriteDemoMessage(sizebuf_t *mesage);
 
 void CL_NextDemo(void);
 void CL_Stop_f(void);
@@ -1051,10 +1253,10 @@ extern cvar_t cl_particles_blood;
 extern cvar_t cl_particles_blood_alpha;
 extern cvar_t cl_particles_blood_bloodhack;
 extern cvar_t cl_particles_bulletimpacts;
-extern cvar_t cl_particles_explosions_bubbles;
-extern cvar_t cl_particles_explosions_smoke;
 extern cvar_t cl_particles_explosions_sparks;
 extern cvar_t cl_particles_explosions_shell;
+extern cvar_t cl_particles_rain;
+extern cvar_t cl_particles_snow;
 extern cvar_t cl_particles_smoke;
 extern cvar_t cl_particles_smoke_alpha;
 extern cvar_t cl_particles_smoke_alphafade;
@@ -1079,7 +1281,6 @@ typedef enum effectnameindex_s
 	EFFECT_TE_SUPERSPIKEQUAD,
 	EFFECT_TE_WIZSPIKE,
 	EFFECT_TE_KNIGHTSPIKE,
-	EFFECT_TE_VORESPIKE,
 	EFFECT_TE_EXPLOSION,
 	EFFECT_TE_EXPLOSIONQUAD,
 	EFFECT_TE_TAREXPLOSION,
@@ -1114,70 +1315,243 @@ effectnameindex_t;
 int CL_ParticleEffectIndexForName(const char *name);
 const char *CL_ParticleEffectNameForIndex(int i);
 void CL_ParticleEffect(int effectindex, float pcount, const vec3_t originmins, const vec3_t originmaxs, const vec3_t velocitymins, const vec3_t velocitymaxs, entity_t *ent, int palettecolor);
+void CL_ParticleTrail(int effectindex, float pcount, const vec3_t originmins, const vec3_t originmaxs, const vec3_t velocitymins, const vec3_t velocitymaxs, entity_t *ent, int palettecolor, qboolean spawndlight, qboolean spawnparticles);
 void CL_ParseParticleEffect (void);
 void CL_ParticleCube (const vec3_t mins, const vec3_t maxs, const vec3_t dir, int count, int colorbase, vec_t gravity, vec_t randomvel);
 void CL_ParticleRain (const vec3_t mins, const vec3_t maxs, const vec3_t dir, int count, int colorbase, int type);
 void CL_EntityParticles (const entity_t *ent);
 void CL_ParticleExplosion (const vec3_t org);
 void CL_ParticleExplosion2 (const vec3_t org, int colorStart, int colorLength);
-void CL_MoveParticles(void);
-void R_MoveExplosions(void);
 void R_NewExplosion(const vec3_t org);
 
+void Debug_PolygonBegin(const char *picname, int flags);
+void Debug_PolygonVertex(float x, float y, float z, float s, float t, float r, float g, float b, float a);
+void Debug_PolygonEnd(void);
+
 #include "cl_screen.h"
 
-#define NUMCROSSHAIRS 32
-extern cachepic_t *r_crosshairs[NUMCROSSHAIRS+1];
+extern qboolean sb_showscores;
 
-typedef struct refdef_s
+float FogPoint_World(const vec3_t p);
+float FogPoint_Model(const vec3_t p);
+float FogForDistance(vec_t dist);
+
+typedef struct r_refdef_stats_s
 {
-	// area to render in
-	int x, y, width, height;
-	float frustum_x, frustum_y;
+	int renders;
+	int entities;
+	int entities_surfaces;
+	int entities_triangles;
+	int world_leafs;
+	int world_portals;
+	int world_surfaces;
+	int world_triangles;
+	int lightmapupdates;
+	int lightmapupdatepixels;
+	int particles;
+	int decals;
+	int meshes;
+	int meshes_elements;
+	int lights;
+	int lights_clears;
+	int lights_scissored;
+	int lights_lighttriangles;
+	int lights_shadowtriangles;
+	int lights_dynamicshadowtriangles;
+	int bloom;
+	int bloom_copypixels;
+	int bloom_drawpixels;
+}
+r_refdef_stats_t;
 
-	// these are set for water warping before
-	// frustum_x/frustum_y are calculated
-	float frustumscale_x, frustumscale_y;
+typedef struct r_refdef_view_s
+{
+	// view information (changes multiple times per frame)
+	// if any of these variables change then r_refdef.viewcache must be regenerated
+	// by calling R_View_Update
+	// (which also updates viewport, scissor, colormask)
+
+	// it is safe and expected to copy this into a structure on the stack and
+	// call the renderer recursively, then restore from the stack afterward
+	// (as long as R_View_Update is called)
 
-	// view transform
-	matrix4x4_t viewentitymatrix;
+	// eye position information
+	matrix4x4_t matrix, inverse_matrix;
+	vec3_t origin;
+	vec3_t forward;
+	vec3_t left;
+	vec3_t right;
+	vec3_t up;
+	int numfrustumplanes;
+	mplane_t frustum[6];
+	qboolean useclipplane;
+	qboolean usecustompvs; // uses r_refdef.viewcache.pvsbits as-is rather than computing it
+	mplane_t clipplane;
+	float frustum_x, frustum_y;
+	vec3_t frustumcorner[4];
+	// if turned off it renders an ortho view
+	int useperspective;
+	float ortho_x, ortho_y;
+
+	// screen area to render in
+	int x;
+	int y;
+	int z;
+	int width;
+	int height;
+	int depth;
 
 	// which color components to allow (for anaglyph glasses)
 	int colormask[4];
 
-	// fullscreen color blend
-	float viewblend[4];
+	// global RGB color multiplier for rendering, this is required by HDR
+	float colorscale;
 
+	// whether to call R_ClearScreen before rendering stuff
+	qboolean clear;
+	// if true, don't clear or do any post process effects (bloom, etc)
+	qboolean isoverlay;
+
+	// whether to draw r_showtris and such, this is only true for the main
+	// view render, all secondary renders (HDR, mirrors, portals, cameras,
+	// distortion effects, etc) omit such debugging information
+	qboolean showdebug;
+
+	// these define which values to use in GL_CullFace calls to request frontface or backface culling
+	int cullface_front;
+	int cullface_back;
+
+	// render quality (0 to 1) - affects r_drawparticles_drawdistance and others
+	float quality;
+}
+r_refdef_view_t;
+
+typedef struct r_refdef_viewcache_s
+{
+	// these properties are generated by R_View_Update()
+
+	// which entities are currently visible for this viewpoint
+	// (the used range is 0...r_refdef.scene.numentities)
+	unsigned char entityvisible[MAX_EDICTS];
+	// flag arrays used for visibility checking on world model
+	// (all other entities have no per-surface/per-leaf visibility checks)
+	// TODO: dynamic resize according to r_refdef.scene.worldmodel->brush.num_clusters
+	unsigned char world_pvsbits[(32768+7)>>3]; // FIXME: buffer overflow on huge maps
+	// TODO: dynamic resize according to r_refdef.scene.worldmodel->brush.num_leafs
+	unsigned char world_leafvisible[32768]; // FIXME: buffer overflow on huge maps
+	// TODO: dynamic resize according to r_refdef.scene.worldmodel->num_surfaces
+	unsigned char world_surfacevisible[262144]; // FIXME: buffer overflow on huge maps
+	// if true, the view is currently in a leaf without pvs data
+	qboolean world_novis;
+}
+r_refdef_viewcache_t;
+
+// TODO: really think about which fields should go into scene and which one should stay in refdef [1/7/2008 Black]
+// maybe also refactor some of the functions to support different setting sources (ie. fogenabled, etc.) for different scenes
+typedef struct r_refdef_scene_s {
 	// whether to call S_ExtraUpdate during render to reduce sound chop
 	qboolean extraupdate;
 
-	// client gameworld time for rendering time based effects
+	// (client gameworld) time for rendering time based effects
 	double time;
 
 	// the world
 	entity_render_t *worldentity;
 
 	// same as worldentity->model
-	model_t *worldmodel;
+	dp_model_t *worldmodel;
 
 	// renderable entities (excluding world)
 	entity_render_t **entities;
 	int numentities;
 	int maxentities;
 
+	// field of temporary entities that is reset each (client) frame
+	entity_render_t *tempentities;
+	int numtempentities;
+	int maxtempentities;
+
 	// renderable dynamic lights
-	dlight_t *lights[MAX_DLIGHTS];
+	rtlight_t lights[MAX_DLIGHTS];
 	int numlights;
 
+	// intensities for light styles right now, controls rtlights
+	float rtlightstylevalue[256];	// float fraction of base light value
 	// 8.8bit fixed point intensities for light styles
-	// controls intensity of dynamic lights and lightmap layers
-	unsigned short	lightstylevalue[256];	// 8.8 fraction of base light value
+	// controls intensity lightmap layers
+	unsigned short lightstylevalue[256];	// 8.8 fraction of base light value
+
+	float ambient;
+
+	qboolean rtworld;
+	qboolean rtworldshadows;
+	qboolean rtdlight;
+	qboolean rtdlightshadows;
+} r_refdef_scene_t;
+
+typedef struct r_refdef_s
+{
+	// these fields define the basic rendering information for the world
+	// but not the view, which could change multiple times in one rendered
+	// frame (for example when rendering textures for certain effects)
+
+	// these are set for water warping before
+	// frustum_x/frustum_y are calculated
+	float frustumscale_x, frustumscale_y;
+
+	// current view settings (these get reset a few times during rendering because of water rendering, reflections, etc)
+	r_refdef_view_t view;
+	r_refdef_viewcache_t viewcache;
+
+	// minimum visible distance (pixels closer than this disappear)
+	double nearclip;
+	// maximum visible distance (pixels further than this disappear in 16bpp modes,
+	// in 32bpp an infinite-farclip matrix is used instead)
+	double farclip;
+
+	// fullscreen color blend
+	float viewblend[4];
+
+	r_refdef_scene_t scene;
+
+	vec3_t fogcolor;
+	vec_t fogrange;
+	vec_t fograngerecip;
+	vec_t fogmasktabledistmultiplier;
+#define FOGMASKTABLEWIDTH 1024
+	float fogmasktable[FOGMASKTABLEWIDTH];
+	float fogmasktable_start, fogmasktable_alpha, fogmasktable_range, fogmasktable_density;
+	float fog_density;
+	float fog_red;
+	float fog_green;
+	float fog_blue;
+	float fog_alpha;
+	float fog_start;
+	float fog_end;
+	qboolean fogenabled;
+	qboolean oldgl_fogenable;
 
 	qboolean draw2dstage;
+
+	// true during envmap command capture
+	qboolean envmap;
+
+	// brightness of world lightmaps and related lighting
+	// (often reduced when world rtlights are enabled)
+	float lightmapintensity;
+	// whether to draw world lights realtime, dlights realtime, and their shadows
+	float polygonfactor;
+	float polygonoffset;
+	float shadowpolygonfactor;
+	float shadowpolygonoffset;
+
+	// rendering stats for r_speeds display
+	// (these are incremented in many places)
+	r_refdef_stats_t stats;
 }
-refdef_t;
+r_refdef_t;
 
-extern refdef_t r_refdef;
+extern r_refdef_t r_refdef;
 
 #endif