X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=client.h;h=16427924bdad29d9df8fcb6bd418fbf75d37670d;hp=5e9df7ded5479e1bda54879fb580813c3e3fca5b;hb=9e10334c3d85c0ff3630fe015f40b5c5a227668a;hpb=440894b67050bb1db5aa0a78b8a35a06944c6b7f

diff --git a/client.h b/client.h
index 5e9df7de..16427924 100644
--- a/client.h
+++ b/client.h
@@ -23,13 +23,13 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #define CLIENT_H
 
 #include "matrixlib.h"
+#include "snd_main.h"
 
 // LordHavoc: 256 dynamic lights
 #define MAX_DLIGHTS 256
 
-// this is the maximum number of input packets that can be lost without a
-// misprediction
-#define CL_MAX_USERCMDS 16
+// 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
@@ -39,7 +39,7 @@ typedef struct effect_s
 {
 	int active;
 	vec3_t origin;
-	float starttime;
+	double starttime;
 	float framerate;
 	int modelindex;
 	int startframe;
@@ -69,6 +69,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)
@@ -108,6 +110,10 @@ typedef struct rtlight_s
 	// rendering properties, updated each time a light is rendered
 	// this is rtlight->color * d_lightstylevalue
 	vec3_t currentcolor;
+	// used by corona updates, due to occlusion query
+	float corona_visibility;
+	unsigned int corona_queryindex_visiblepixels;
+	unsigned int corona_queryindex_allpixels;
 	// this is R_Shadow_Cubemap(rtlight->cubemapname)
 	rtexture_t *currentcubemap;
 
@@ -117,7 +123,8 @@ typedef struct rtlight_s
 	// true if this is a compiled world light, cleared if the light changes
 	int compiled;
 	// premade shadow volumes to render for world entity
-	shadowmesh_t *static_meshchain_shadow;
+	shadowmesh_t *static_meshchain_shadow_zpass;
+	shadowmesh_t *static_meshchain_shadow_zfail;
 	// used for visibility testing (more exact than bbox)
 	int static_numleafs;
 	int static_numleafpvsbytes;
@@ -215,15 +222,38 @@ typedef struct dlight_s
 }
 dlight_t;
 
-typedef struct frameblend_s
+#define MAX_FRAMEGROUPBLENDS 4
+typedef struct framegroupblend_s
 {
+	// animation number and blend factor
+	// (for most models this is the frame number)
 	int frame;
 	float lerp;
+	// time frame began playing (for framegroup animations)
+	double start;
+}
+framegroupblend_t;
+
+// this is derived from processing of the framegroupblend array
+// note: technically each framegroupblend can produce two of these, but that
+// never happens in practice because no one blends between more than 2
+// framegroups at once
+#define MAX_FRAMEBLENDS MAX_FRAMEGROUPBLENDS
+typedef struct frameblend_s
+{
+	int subframe;
+	float lerp;
 }
 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
@@ -240,16 +270,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
@@ -258,31 +288,25 @@ typedef struct entity_render_s
 	// colormod tinting of models
 	float colormod[3];
 
-	// interpolated animation
+	// interpolated animation - active framegroups and blend factors
+	framegroupblend_t framegroupblend[MAX_FRAMEGROUPBLENDS];
 
-	// frame that the model is interpolating from
-	int frame1;
-	// frame that the model is interpolating to
-	int frame2;
-	// interpolation factor, usually computed from frame2time
-	float framelerp;
-	// time frame1 began playing (for framegroup animations)
-	double frame1time;
-	// time frame2 began playing (for framegroup animations)
-	double frame2time;
+	// time of last model change (for shader animations)
+	double shadertime;
 
 	// calculated by the renderer (but not persistent)
 
 	// 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];
+	// subframe numbers (-1 if not used) and their blending scalers (0-1), if interpolation is not desired, use subframeblend[0].subframe
+	frameblend_t frameblend[MAX_FRAMEBLENDS];
 
-	// 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;
 }
@@ -294,6 +318,7 @@ typedef struct entity_persistent_s
 
 	// particle trail
 	float trail_time;
+	qboolean trail_allowed; // set to false by teleports, true by update code, prevents bad lerps
 
 	// muzzleflash fading
 	float muzzleflash;
@@ -346,13 +371,21 @@ typedef struct usercmd_s
 	vec_t	cursor_fraction;
 	int		cursor_entitynumber;
 
-	double time;
-	double receivetime;
-	int msec; // for qw moves
+	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
@@ -380,7 +413,8 @@ typedef struct scoreboard_s
 typedef struct cshift_s
 {
 	float	destcolor[3];
-	float	percent;		// 0-256
+	float	percent;		// 0-255
+	float   alphafade;      // (any speed)
 } cshift_t;
 
 #define	CSHIFT_CONTENTS	0
@@ -404,6 +438,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
@@ -422,36 +457,51 @@ qw_downloadtype_t;
 
 typedef enum capturevideoformat_e
 {
-	CAPTUREVIDEOFORMAT_AVI_I420
+	CAPTUREVIDEOFORMAT_AVI_I420,
+	CAPTUREVIDEOFORMAT_OGG_VORBIS_THEORA,
 }
 capturevideoformat_t;
 
 typedef struct capturevideostate_s
 {
-	double starttime;
+	double startrealtime;
 	double framerate;
-	// for AVI saving some values have to be written after capture ends
-	fs_offset_t videofile_totalframes_offset1;
-	fs_offset_t videofile_totalframes_offset2;
-	fs_offset_t videofile_totalsampleframes_offset;
-	qfile_t *videofile;
 	qboolean active;
 	qboolean realtime;
 	qboolean error;
-	capturevideoformat_t format;
 	int soundrate;
+	int soundchannels;
 	int frame;
-	int soundsampleframe; // for AVI saving
-	unsigned char *buffer;
-	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];
+	double starttime;
+	double lastfpstime;
+	int lastfpsframe;
+	int soundsampleframe;
+	unsigned char *screenbuffer;
+	unsigned char *outbuffer;
+	char basename[MAX_QPATH];
+	int width, height;
+
+	// precomputed RGB to YUV tables
+	// converts the RGB values to YUV (see cap_avi.c for how to use them)
 	short rgbtoyuvscaletable[3][3][256];
 	unsigned char yuvnormalizetable[3][256];
-	char basename[64];
+
+	// precomputed gamma ramp (only needed if the capturevideo module uses RGB output)
+	// note: to map from these values to RGB24, you have to multiply by 255.0/65535.0, then add 0.5, then cast to integer
+	unsigned short vidramp[256 * 3];
+
+	// stuff to be filled in by the video format module
+	capturevideoformat_t format;
+	const char *formatextension;
+	qfile_t *videofile;
+		// always use this:
+		//   cls.capturevideo.videofile = FS_OpenRealFile(va("%s.%s", cls.capturevideo.basename, cls.capturevideo.formatextension), "wb", false);
+	void (*endvideo) ();
+	void (*videoframes) (int num);
+	void (*soundframe) (const portable_sampleframe_t *paintbuffer, size_t length);
+
+	// format specific data
+	void *formatspecific;
 }
 capturevideostate_t;
 
@@ -463,6 +513,14 @@ typedef struct cl_downloadack_s
 }
 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
@@ -481,31 +539,34 @@ typedef struct client_static_s
 	// list of demos in loop
 	char demos[MAX_DEMOS][MAX_DEMONAME];
 	// the actively playing demo (set by CL_PlayDemo_f)
-	char demoname[64];
+	char demoname[MAX_QPATH];
 
 // demo recording info must be here, because record is started before
 // entering a map (and clearing client_state_t)
 	qboolean demorecording;
+	fs_offset_t demo_lastcsprogssize;
+	int demo_lastcsprogscrc;
 	qboolean demoplayback;
 	qboolean timedemo;
 	// -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;
+	int td_frames; // total frames parsed
 	double td_onesecondnexttime;
 	double td_onesecondframes;
-	double td_onesecondminframes;
-	double td_onesecondmaxframes;
-	double td_onesecondavgframes;
+	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;
@@ -549,6 +610,7 @@ typedef struct client_static_s
 	double qw_downloadspeedtime;
 	int qw_downloadspeedcount;
 	int qw_downloadspeedrate;
+	qboolean qw_download_deflate;
 
 	// current file upload buffer (for uploading screenshots to server)
 	unsigned char *qw_uploaddata;
@@ -576,6 +638,7 @@ typedef struct client_movementqueue_s
 	float move[3];
 	qboolean jump;
 	qboolean crouch;
+	qboolean canjump;
 }
 client_movementqueue_t;
 
@@ -592,7 +655,8 @@ typedef enum
 	PARTICLE_BILLBOARD = 0,
 	PARTICLE_SPARK = 1,
 	PARTICLE_ORIENTED_DOUBLESIDED = 2,
-	PARTICLE_BEAM = 3
+	PARTICLE_BEAM = 3,
+	PARTICLE_INVALID = -1
 }
 porientation_t;
 
@@ -600,7 +664,8 @@ typedef enum
 {
 	PBLEND_ALPHA = 0,
 	PBLEND_ADD = 1,
-	PBLEND_MOD = 2
+	PBLEND_INVMOD = 2,
+	PBLEND_INVALID = -1
 }
 pblend_t;
 
@@ -614,30 +679,58 @@ 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:  (44 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;
+	int				clusterindex; // cheap culling by pvs
+
+	// 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 int		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 char   typeindex;
+	pblend_t   blendmode;
+	porientation_t   orientation;
+	unsigned char   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
+	float           stretch; // only for sparks
+
+	// 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;
 
@@ -651,6 +744,24 @@ typedef enum cl_parsingtextmode_e
 }
 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
@@ -671,6 +782,7 @@ typedef struct client_state_s
 // 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
@@ -719,18 +831,9 @@ typedef struct client_state_s
 	qboolean movement_predicted;
 	// if true the CL_ClientMovement_Replay function will update origin, etc
 	qboolean movement_replay;
-	// this is set true by svc_time parsing and causes a new movement to be
-	// queued for prediction purposes
-	qboolean movement_needupdate;
-	// timestamps of latest two predicted moves for interpolation
-	double movement_time[4];
 	// 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[256];
 	// whether the replay should allow a jump at the first sequence
 	qboolean movement_replay_canjump;
 
@@ -795,6 +898,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;
@@ -802,10 +910,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;
@@ -813,6 +921,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
 
@@ -860,35 +970,41 @@ typedef struct client_state_s
 
 	int max_entities;
 	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;
 	unsigned char *entities_active;
 	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_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;
@@ -898,6 +1014,7 @@ typedef struct client_state_s
 	int downloadsound_current;
 	int loadsound_total;
 	qboolean downloadcsqc;
+	qboolean loadcsqc;
 	qboolean loadbegun;
 	qboolean loadfinished;
 
@@ -916,20 +1033,31 @@ typedef struct client_state_s
 	int qw_teamplay;
 
 	// unused: indicates whether the player is spectating
-	// use cl.scores[cl.playerentity].qw_spectator instead
+	// 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;
@@ -951,9 +1079,28 @@ typedef struct client_state_s
 	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;
 
@@ -986,7 +1133,9 @@ extern cvar_t cl_autofire;
 
 extern cvar_t cl_shownet;
 extern cvar_t cl_nolerp;
-extern cvar_t cl_nettimesyncmode;
+extern cvar_t cl_nettimesyncfactor;
+extern cvar_t cl_nettimesyncboundmode;
+extern cvar_t cl_nettimesyncboundtolerance;
 
 extern cvar_t cl_pitchdriftspeed;
 extern cvar_t lookspring;
@@ -1015,10 +1164,15 @@ 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_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);
+
 //=============================================================================
 
 //
@@ -1034,6 +1188,7 @@ void CL_Disconnect (void);
 void CL_Disconnect_f (void);
 
 void CL_UpdateRenderEntity(entity_render_t *ent);
+void CL_SetEntityColormapColors(entity_render_t *ent, int colormap);
 void CL_UpdateViewEntities(void);
 
 //
@@ -1057,13 +1212,13 @@ 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, model_t *m, int lightning);
+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 (double shadertime);
 
 void CL_Effect(vec3_t org, int modelindex, int startframe, int framecount, float framerate);
 
@@ -1072,10 +1227,10 @@ 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_Input (void);
-extern qboolean cl_ignoremousemove;
+extern int cl_ignoremousemoves;
 
 
 float CL_KeyState (kbutton_t *key);
@@ -1087,7 +1242,10 @@ 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_CutDemo(unsigned char **buf, fs_offset_t *filesize);
+void CL_PasteDemo(unsigned char **buf, fs_offset_t *filesize);
 
 void CL_NextDemo(void);
 void CL_Stop_f(void);
@@ -1105,6 +1263,7 @@ void CL_Parse_DumpPacket(void);
 void CL_Parse_ErrorCleanUp(void);
 void QW_CL_StartUpload(unsigned char *data, int size);
 extern cvar_t qport;
+void CL_KeepaliveMessage(qboolean readmessages); // call this during loading of large content
 
 //
 // view
@@ -1129,9 +1288,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_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;
@@ -1197,11 +1357,9 @@ void CL_ParticleRain (const vec3_t mins, const vec3_t maxs, const vec3_t dir, in
 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, qboolean draw2d, float linewidth);
+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);
 
@@ -1209,21 +1367,24 @@ void Debug_PolygonEnd(void);
 
 extern qboolean sb_showscores;
 
-#define NUMCROSSHAIRS 32
-extern cachepic_t *r_crosshairs[NUMCROSSHAIRS+1];
-
-#define FOGTABLEWIDTH 1024
-extern int fogtableindex;
-#define VERTEXFOGTABLE(dist) (fogtableindex = (int)((dist) * r_refdef.fogtabledistmultiplier), r_refdef.fogtable[bound(0, fogtableindex, FOGTABLEWIDTH - 1)])
+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
 {
+	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;
@@ -1238,59 +1399,171 @@ typedef struct r_refdef_stats_s
 }
 r_refdef_stats_t;
 
-typedef struct r_refdef_s
+typedef struct r_refdef_view_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)
+	// 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)
 
-	// these are set for water warping before
-	// frustum_x/frustum_y are calculated
-	float frustumscale_x, frustumscale_y;
+	// 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)
 
-	// 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;
+	// 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;
 
-	// fullscreen color blend
-	float viewblend[4];
+	// 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];
 
+	// 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
-	rtlight_t lights[MAX_DLIGHTS];
+	rtlight_t *lights[MAX_DLIGHTS];
+	rtlight_t templights[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 fogtabledistmultiplier;
-	float fogtable[FOGTABLEWIDTH];
+	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;
 
@@ -1303,10 +1576,6 @@ typedef struct r_refdef_s
 	// (often reduced when world rtlights are enabled)
 	float lightmapintensity;
 	// whether to draw world lights realtime, dlights realtime, and their shadows
-	qboolean rtworld;
-	qboolean rtworldshadows;
-	qboolean rtdlight;
-	qboolean rtdlightshadows;
 	float polygonfactor;
 	float polygonoffset;
 	float shadowpolygonfactor;
@@ -1318,66 +1587,7 @@ typedef struct r_refdef_s
 }
 r_refdef_t;
 
-typedef struct r_view_s
-{
-	// view information (changes multiple times per frame)
-	// if any of these variables change then r_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)
-
-	// eye position information
-	matrix4x4_t matrix;
-	vec3_t origin;
-	vec3_t forward;
-	vec3_t left;
-	vec3_t right;
-	vec3_t up;
-	mplane_t frustum[5];
-	float frustum_x, frustum_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];
-
-	// global RGB color multiplier for rendering, this is required by HDR
-	float colorscale;
-}
-r_view_t;
-
-typedef struct r_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.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.worldmodel->brush.num_clusters
-	unsigned char world_pvsbits[(32768+7)>>3];
-	// TODO: dynamic resize according to r_refdef.worldmodel->brush.num_leafs
-	unsigned char world_leafvisible[32768];
-	// TODO: dynamic resize according to r_refdef.worldmodel->num_surfaces
-	unsigned char world_surfacevisible[262144];
-	// if true, the view is currently in a leaf without pvs data
-	qboolean world_novis;
-}
-r_viewcache_t;
-
 extern r_refdef_t r_refdef;
-extern r_view_t r_view;
-extern r_viewcache_t r_viewcache;
 
 #endif