#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 predicted
-#define CL_MAX_USERCMDS 256
+#include "view.h"
+#include "cap.h"
+#include "cl_parse.h"
+#include "cl_particles.h"
+#include "r_stats.h"
// flags for rtlight rendering
#define LIGHTFLAG_NORMALMODE 1
#define LIGHTFLAG_REALTIMEMODE 2
+typedef struct tridecal_s
+{
+ // color and initial alpha value
+ float texcoord2f[3][2];
+ float vertex3f[3][3];
+ float color4f[3][4];
+ float plane[4]; // backface culling
+ // how long this decal has lived so far (the actual fade begins at cl_decals_time)
+ float lived;
+ // if >= 0 this indicates the decal should follow an animated triangle
+ int triangleindex;
+ // for visibility culling
+ int surfaceindex;
+ // old decals are killed to obey cl_decals_max
+ unsigned int decalsequence;
+}
+tridecal_t;
+
+typedef struct decalsystem_s
+{
+ model_t *model;
+ double lastupdatetime;
+ int maxdecals;
+ int freedecal;
+ int numdecals;
+ tridecal_t *decals;
+ float *vertex3f;
+ float *texcoord2f;
+ float *color4f;
+ int *element3i;
+ unsigned short *element3s;
+}
+decalsystem_t;
+
typedef struct effect_s
{
int active;
vec3_t origin;
double starttime;
float framerate;
- int modelindex;
+ model_t *model;
int startframe;
int endframe;
// these are for interpolation
}
beam_t;
-typedef struct rtlight_s
+typedef struct rtlight_particle_s
{
- // shadow volumes are done entirely in model space, so there are no matrices for dealing with them... they just use the origin
+ float origin[3];
+ float color[3];
+}
+rtlight_particle_t;
+typedef struct rtlight_s
+{
// note that the world to light matrices are inversely scaled (divided) by lightradius
// core properties
char cubemapname[64];
/// light style to monitor for brightness
int style;
- /// whether light should render shadows
+ /// whether light should render shadows (see castshadows for whether it actually does this frame)
int shadow;
/// intensity of corona to render
vec_t corona;
int flags;
// generated properties
- /// used only for shadow volumes
+ /// used only for casting shadows
vec3_t shadoworigin;
/// culling
vec3_t cullmins;
vec3_t cullmaxs;
- // culling
- //vec_t cullradius;
- // squared cullradius
- //vec_t cullradius2;
+ /// when r_shadow_culllights_trace is set, this is refreshed by each successful trace.
+ double trace_timer;
// rendering properties, updated each time a light is rendered
// this is rtlight->color * d_lightstylevalue
float corona_visibility;
unsigned int corona_queryindex_visiblepixels;
unsigned int corona_queryindex_allpixels;
- /// this is R_Shadow_Cubemap(rtlight->cubemapname)
+ /// this is R_GetCubemap(rtlight->cubemapname)
rtexture_t *currentcubemap;
+ /// set by R_Shadow_PrepareLight to decide whether R_Shadow_DrawLight should draw it
+ qbool draw;
+ /// set by R_Shadow_PrepareLight to indicate whether R_Shadow_DrawShadowMaps should do anything
+ qbool castshadows;
+ /// these fields are set by R_Shadow_PrepareLight for later drawing
+ int cached_numlightentities;
+ int cached_numlightentities_noselfshadow;
+ int cached_numshadowentities;
+ int cached_numshadowentities_noselfshadow;
+ int cached_numsurfaces;
+ struct entity_render_s **cached_lightentities;
+ struct entity_render_s **cached_lightentities_noselfshadow;
+ struct entity_render_s **cached_shadowentities;
+ struct entity_render_s **cached_shadowentities_noselfshadow;
+ unsigned char *cached_shadowtrispvs;
+ unsigned char *cached_lighttrispvs;
+ int *cached_surfacelist;
+ // reduced light cullbox from GetLightInfo
+ vec3_t cached_cullmins;
+ vec3_t cached_cullmaxs;
+ // current shadow-caster culling planes based on view
+ // (any geometry outside these planes can not contribute to the visible
+ // shadows in any way, and thus can be culled safely)
+ int cached_numfrustumplanes;
+ mplane_t cached_frustumplanes[5]; // see R_Shadow_ComputeShadowCasterCullingPlanes
/// static light info
/// true if this light should be compiled as a static light
int isstatic;
/// 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_zpass;
- shadowmesh_t *static_meshchain_shadow_zfail;
+ /// the size that this light should have (assuming no scene LOD kicking in to reduce it)
+ int shadowmapsidesize;
+ /// position of this light in the shadowmap atlas
+ int shadowmapatlasposition[2];
+ /// size of one side of this light in the shadowmap atlas (for omnidirectional shadowmaps this is the min corner of a 2x3 arrangement, or a 4x3 arrangement in the case of noselfshadow entities being present)
+ int shadowmapatlassidesize;
+ /// optimized and culled mesh to render for world entity shadows
+ shadowmesh_t *static_meshchain_shadow_shadowmap;
/// used for visibility testing (more exact than bbox)
int static_numleafs;
int static_numleafpvsbytes;
/// (important on big surfaces such as terrain)
int static_numlighttrispvsbytes;
unsigned char *static_lighttrispvs;
+ /// masks of all shadowmap sides that have any potential static receivers or casters
+ int static_shadowmap_receivers;
+ int static_shadowmap_casters;
+ /// particle-tracing cache for global illumination
+ int particlecache_numparticles;
+ int particlecache_maxparticles;
+ int particlecache_updateparticle;
+ rtlight_particle_t *particlecache_particles;
+
+ /// bouncegrid light info
+ float bouncegrid_photoncolor[3];
+ float bouncegrid_photons;
+ int bouncegrid_hits;
+ int bouncegrid_traces;
+ float bouncegrid_effectiveradius;
}
rtlight_t;
}
dlight_t;
-#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
+#define MAX_FRAMEBLENDS (MAX_FRAMEGROUPBLENDS * 2)
typedef struct frameblend_s
{
int subframe;
}
frameblend_t;
-// LordHavoc: this struct is intended for the renderer but some fields are
+// LadyHavoc: 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
float alpha;
// size the model is shown
float scale;
+ // transparent sorting offset
+ float transparent_offset;
// NULL = no model
- dp_model_t *model;
+ 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
// colormod tinting of models
float colormod[3];
+ float glowmod[3];
// interpolated animation - active framegroups and blend factors
framegroupblend_t framegroupblend[MAX_FRAMEGROUPBLENDS];
vec3_t mins, maxs;
// 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];
-
- // animation cache index
- int animcacheindex;
-
- // 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
+ // skeletal animation data (if skeleton.relativetransforms is not NULL, it overrides frameblend)
+ skeleton_t *skeleton;
+
+ // animation cache (pointers allocated using R_FrameData_Alloc)
+ // ONLY valid during R_RenderView! may be NULL (not cached)
+ float *animcache_vertex3f;
+ r_meshbuffer_t *animcache_vertex3f_vertexbuffer;
+ int animcache_vertex3f_bufferoffset;
+ float *animcache_normal3f;
+ r_meshbuffer_t *animcache_normal3f_vertexbuffer;
+ int animcache_normal3f_bufferoffset;
+ float *animcache_svector3f;
+ r_meshbuffer_t *animcache_svector3f_vertexbuffer;
+ int animcache_svector3f_bufferoffset;
+ float *animcache_tvector3f;
+ r_meshbuffer_t *animcache_tvector3f_vertexbuffer;
+ int animcache_tvector3f_bufferoffset;
+ // gpu-skinning shader needs transforms in a certain format, we have to
+ // upload this to a uniform buffer for the shader to use, and also keep a
+ // backup copy in system memory for the dynamic batch fallback code
+ // if this is not NULL, the other animcache variables are NULL
+ float *animcache_skeletaltransform3x4;
+ r_meshbuffer_t *animcache_skeletaltransform3x4buffer;
+ int animcache_skeletaltransform3x4offset;
+ int animcache_skeletaltransform3x4size;
+
+ // CL_UpdateEntityShading reads these fields
+ // used only if RENDER_CUSTOMIZEDMODELLIGHT is set
+ vec3_t custommodellight_ambient;
+ vec3_t custommodellight_diffuse;
+ vec3_t custommodellight_lightdir;
+ // CSQC entities get their shading from the root of their attachment chain
+ float custommodellight_origin[3];
+
+ // derived lighting parameters (CL_UpdateEntityShading)
+
+ // used by MATERIALFLAG_FULLBRIGHT which is MATERIALFLAG_MODELLIGHT with
+ // this as ambient color, along with MATERIALFLAG_NORTLIGHT
+ float render_fullbright[3];
+ // color tint for the base pass glow textures if any
+ float render_glowmod[3];
+ // MATERIALFLAG_MODELLIGHT uses these parameters
+ float render_modellight_ambient[3];
+ float render_modellight_diffuse[3];
+ float render_modellight_lightdir_world[3];
+ float render_modellight_lightdir_local[3];
+ float render_modellight_specular[3];
+ // lightmap rendering (not MATERIALFLAG_MODELLIGHT)
+ float render_lightmap_ambient[3];
+ float render_lightmap_diffuse[3];
+ float render_lightmap_specular[3];
+ // rtlights use these colors for the materials on this entity
+ float render_rtlight_diffuse[3];
+ float render_rtlight_specular[3];
+ // ignore lightmap and use fixed lighting settings on this entity (e.g. FULLBRIGHT)
+ qbool render_modellight_forced;
+ // do not process per pixel lights on this entity at all (like MATERIALFLAG_NORTLIGHT)
+ qbool render_rtlight_disabled;
+ // use the 3D lightmap from q3bsp on this entity
+ qbool render_lightgrid;
+
+ // storage of decals on this entity
+ // (note: if allowdecals is set, be sure to call R_DecalSystem_Reset on removal!)
+ int allowdecals;
+ decalsystem_t decalsystem;
// FIELDS UPDATED BY RENDERER:
// last time visible during trace culling
double last_trace_visibility;
+
+ // user wavefunc parameters (from csqc)
+ vec_t userwavefunc_param[Q3WAVEFUNC_USER_COUNT];
}
entity_render_t;
typedef struct entity_persistent_s
{
- 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;
-
- // interpolated movement
-
- // start time of move
- float lerpstarttime;
- // time difference from start to end of move
- float lerpdeltatime;
- // the move itself, start and end
- float oldorigin[3];
- float oldangles[3];
- float neworigin[3];
- float newangles[3];
+ vec3_t trail_origin; // previous position for particle trail spawning
+ vec3_t oldorigin; // lerp
+ vec3_t oldangles; // lerp
+ vec3_t neworigin; // lerp
+ vec3_t newangles; // lerp
+ vec_t lerpstarttime; // lerp
+ vec_t lerpdeltatime; // lerp
+ float muzzleflash; // muzzleflash intensity, fades over time
+ float trail_time; // residual error accumulation for particle trail spawning (to keep spacing across frames)
+ qbool trail_allowed; // set to false by teleports, true by update code, prevents bad lerps
}
entity_persistent_t;
}
entity_t;
-typedef struct usercmd_s
-{
- vec3_t viewangles;
-
-// intended velocities
- float forwardmove;
- float sidemove;
- float upmove;
-
- vec3_t cursor_screen;
- vec3_t cursor_start;
- vec3_t cursor_end;
- vec3_t cursor_impact;
- vec3_t cursor_normal;
- vec_t cursor_fraction;
- int cursor_entitynumber;
-
- 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
{
int length;
float qw_entertime;
int qw_ping;
int qw_packetloss;
+ int qw_movementloss;
int qw_spectator;
char qw_team[8];
char qw_skin[MAX_QPATH];
#define SIGNONS 4 // signon messages to receive before connected
-#define MAX_DEMOS 8
-#define MAX_DEMONAME 16
-
typedef enum cactive_e
{
ca_uninitialized, // during early startup
}
qw_downloadtype_t;
-typedef enum capturevideoformat_e
-{
- CAPTUREVIDEOFORMAT_AVI_I420,
- CAPTUREVIDEOFORMAT_OGG_VORBIS_THEORA,
-}
-capturevideoformat_t;
-
-typedef struct capturevideostate_s
-{
- double startrealtime;
- double framerate;
- int framestep;
- int framestepframe;
- qboolean active;
- qboolean realtime;
- qboolean error;
- int soundrate;
- int soundchannels;
- int frame;
- 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];
-
- // 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);
- void (*videoframes) (int num);
- void (*soundframe) (const portable_sampleframe_t *paintbuffer, size_t length);
-
- // format specific data
- void *formatspecific;
-}
-capturevideostate_t;
-
#define CL_MAX_DOWNLOADACKS 4
typedef struct cl_downloadack_s
int demonum;
// list of demos in loop
char demos[MAX_DEMOS][MAX_DEMONAME];
- // the actively playing demo (set by CL_PlayDemo_f)
+ // the actively playing demo (set by CL_PlayDemo)
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;
+ qbool demorecording;
fs_offset_t demo_lastcsprogssize;
int demo_lastcsprogscrc;
- qboolean demoplayback;
- qboolean timedemo;
+ qbool demoplayback;
+ qbool demostarting; // set if currently starting a demo, to stop -demo from quitting when switching to another demo
+ qbool timedemo;
// -1 = use normal cd track
int forcetrack;
qfile_t *demofile;
- // realtime at second frame of timedemo (LordHavoc: changed to double)
+ // realtime at second frame of timedemo (LadyHavoc: changed to double)
double td_starttime;
int td_frames; // total frames parsed
double td_onesecondnexttime;
double td_onesecondmaxfps;
double td_onesecondavgfps;
int td_onesecondavgcount;
- // LordHavoc: pausedemo
- qboolean demopaused;
+ // LadyHavoc: pausedemo
+ qbool demopaused;
// sound mixer statistics for showsound display
cl_soundstats_t soundstats;
- qboolean connect_trying;
+ qbool connect_trying;
int connect_remainingtries;
double connect_nextsendtime;
lhnetsocket_t *connect_mysocket;
lhnetaddress_t connect_address;
+ lhnetaddress_t rcon_address;
// protocol version of the server we're connected to
// (kept outside client_state_t because it's used between levels)
protocolversion_t protocol;
+#define MAX_RCONS 16
+ int rcon_trying;
+ lhnetaddress_t rcon_addresses[MAX_RCONS];
+ char rcon_commands[MAX_RCONS][MAX_INPUTLINE];
+ double rcon_timeout[MAX_RCONS];
+ int rcon_ringpos;
+
// connection information
// 0 to SIGNONS
int signon;
cl_downloadack_t dp_downloadack[CL_MAX_DOWNLOADACKS];
// input sequence numbers are not reset on level change, only connect
- int movesequence;
- int servermovesequence;
+ unsigned 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;
+ unsigned int qw_incoming_sequence;
+ unsigned int qw_outgoing_sequence;
// current file download buffer (only saved when file is completed)
char qw_downloadname[MAX_QPATH];
double qw_downloadspeedtime;
int qw_downloadspeedcount;
int qw_downloadspeedrate;
- qboolean qw_download_deflate;
+ qbool qw_download_deflate;
// current file upload buffer (for uploading screenshots to server)
unsigned char *qw_uploaddata;
// password spectator name team skin topcolor bottomcolor rate noaim msg *ver *ip
char userinfo[MAX_USERINFO_STRING];
+ // extra user info for the "connect" command
+ char connect_userinfo[MAX_USERINFO_STRING];
+
+#ifdef CONFIG_VIDEO_CAPTURE
// video capture stuff
capturevideostate_t capturevideo;
-}
-client_static_t;
-
-extern client_static_t cls;
-
-typedef struct client_movementqueue_s
-{
- double time;
- float frametime;
- int sequence;
- float viewangles[3];
- float move[3];
- qboolean jump;
- qboolean crouch;
- qboolean canjump;
-}
-client_movementqueue_t;
+#endif
-//[515]: csqc
-typedef struct
-{
- qboolean drawworld;
- qboolean drawenginesbar;
- qboolean drawcrosshair;
-}csqc_vidvars_t;
+ // crypto channel
+ crypto_t crypto;
-typedef enum
-{
- PARTICLE_BILLBOARD = 0,
- PARTICLE_SPARK = 1,
- PARTICLE_ORIENTED_DOUBLESIDED = 2,
- PARTICLE_VBEAM = 3,
- PARTICLE_HBEAM = 4,
- PARTICLE_INVALID = -1
-}
-porientation_t;
+ // ProQuake compatibility stuff
+ int proquake_servermod; // 0 = not proquake, 1 = proquake
+ int proquake_serverversion; // actual proquake server version * 10 (3.40 = 34, etc)
+ int proquake_serverflags; // 0 (PQF_CHEATFREE not supported)
-typedef enum
-{
- PBLEND_ALPHA = 0,
- PBLEND_ADD = 1,
- PBLEND_INVMOD = 2,
- PBLEND_INVALID = -1
-}
-pblend_t;
+ // don't write-then-read csprogs.dat (useful for demo playback)
+ unsigned char *caughtcsprogsdata;
+ fs_offset_t caughtcsprogsdatasize;
-typedef struct particletype_s
-{
- pblend_t blendmode;
- porientation_t orientation;
- qboolean lighting;
-}
-particletype_t;
+ int r_speeds_graph_length;
+ int r_speeds_graph_current;
+ int *r_speeds_graph_data;
-typedef enum
-{
- 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
+ // graph scales
+ int r_speeds_graph_datamin[r_stat_count];
+ int r_speeds_graph_datamax[r_stat_count];
}
-ptype_t;
+client_static_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;
+extern client_static_t cls;
-typedef struct particle_s
+//[515]: csqc
+typedef struct
{
- // 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
- int staincolor;
- signed char staintexnum;
- float stainsizefactor;
-
- // 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;
+ qbool drawworld;
+ qbool drawenginesbar;
+ qbool drawcrosshair;
+}csqc_vidvars_t;
typedef enum cl_parsingtextmode_e
{
typedef struct showlmp_s
{
- qboolean isactive;
+ qbool isactive;
float x;
float y;
char label[32];
// this is used primarily by teleporters, and when spectating players
// special checking of the old fixangle[1] is used to differentiate
// between teleporting and spectating
- qboolean fixangle[2];
+ qbool fixangle[2];
// client movement simulation
// these fields are only updated by CL_ClientMovement (called by CL_SendMove after parsing each network packet)
// set by CL_ClientMovement_Replay functions
- qboolean movement_predicted;
+ qbool movement_predicted;
// if true the CL_ClientMovement_Replay function will update origin, etc
- qboolean movement_replay;
+ qbool movement_replay;
// simulated data (this is valid even if cl.movement is false)
vec3_t movement_origin;
vec3_t movement_velocity;
// whether the replay should allow a jump at the first sequence
- qboolean movement_replay_canjump;
+ qbool movement_replay_canjump;
+
+ // previous gun angles (for leaning effects)
+ vec3_t gunangles_prev;
+ vec3_t gunangles_highpass;
+ vec3_t gunangles_adjustment_lowpass;
+ vec3_t gunangles_adjustment_highpass;
+ // previous gun angles (for leaning effects)
+ vec3_t gunorg_prev;
+ vec3_t gunorg_highpass;
+ vec3_t gunorg_adjustment_lowpass;
+ vec3_t gunorg_adjustment_highpass;
// pitch drifting vars
float idealpitch;
float pitchvel;
- qboolean nodrift;
+ qbool nodrift;
float driftmove;
double laststop;
//[515]: added for csqc purposes
float sensitivityscale;
csqc_vidvars_t csqc_vidvars; //[515]: these parms must be set to true by default
- qboolean csqc_wantsmousemove;
+ qbool csqc_wantsmousemove;
struct model_s *csqc_model_precache[MAX_MODELS];
// local amount for smoothing stepups
//float crouch;
// sent by server
- qboolean paused;
- qboolean onground;
- qboolean inwater;
+ qbool paused;
+ qbool onground;
+ qbool inwater;
// used by bob
- qboolean oldonground;
+ qbool oldonground;
double lastongroundtime;
double hitgroundtime;
+ float bob2_smooth;
+ float bobfall_speed;
+ float bobfall_swing;
+ double calcrefdef_prevtime;
// don't change view angle, full screen, etc
int intermission;
// (not game time, for that use cl.time - cl.oldtime)
double realframetime;
+ // used by cl_nettimesyncboundmode 7
+#define NUM_TS_ERRORS 32 // max 256
+ unsigned char ts_error_num;
+ float ts_error_stor[NUM_TS_ERRORS];
+
+ // fade var for fading while dead
+ float deathfade;
+
+ // motionblur alpha level variable
+ float motionbluralpha;
+
// copy of realtime from last recieved message, for net trouble icon
float last_received_message;
char sound_name[MAX_SOUNDS][MAX_QPATH];
// for display on solo scoreboard
- char levelname[40];
+ char worldmessage[40]; // map title (not related to filename)
+ // variants of map name
+ char worldbasename[MAX_QPATH]; // %s
+ char worldname[MAX_QPATH]; // maps/%s.bsp
+ char worldnamenoextension[MAX_QPATH]; // maps/%s
// cl_entitites[cl.viewentity] = player
int viewentity;
// the real player entity (normally same as viewentity,
int gametype;
// models and sounds used by engine code (particularly cl_parse.c)
- dp_model_t *model_bolt;
- dp_model_t *model_bolt2;
- dp_model_t *model_bolt3;
- dp_model_t *model_beam;
+ model_t *model_bolt;
+ model_t *model_bolt2;
+ model_t *model_bolt3;
+ model_t *model_beam;
sfx_t *sfx_wizhit;
sfx_t *sfx_knighthit;
sfx_t *sfx_tink1;
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;
+ qbool foundteamchatsound;
// refresh related state
// entity database stuff
// latest received entity frame numbers
-#define LATESTFRAMENUMS 3
+#define LATESTFRAMENUMS 32
+ int latestframenumsposition;
int latestframenums[LATESTFRAMENUMS];
+ unsigned int latestsendnums[LATESTFRAMENUMS];
entityframe_database_t *entitydatabase;
entityframe4_database_t *entitydatabase4;
entityframeqw_database_t *entitydatabaseqw;
vec3_t playercrouchmins;
vec3_t playercrouchmaxs;
+ // old decals are killed based on this
+ unsigned int decalsequence;
+
int max_entities;
+ int max_csqcrenderentities;
int max_static_entities;
int max_effects;
int max_beams;
int max_lightstyle;
int max_brushmodel_entities;
int max_particles;
- int max_decals;
int max_showlmps;
entity_t *entities;
+ entity_render_t *csqcrenderentities;
unsigned char *entities_active;
entity_t *static_entities;
cl_effect_t *effects;
lightstyle_t *lightstyle;
int *brushmodel_entities;
particle_t *particles;
- decal_t *decals;
showlmp_t *showlmps;
int num_entities;
int loadsound_current;
int downloadsound_current;
int loadsound_total;
- qboolean downloadcsqc;
- qboolean loadcsqc;
- qboolean loadbegun;
- qboolean loadfinished;
+ qbool downloadcsqc;
+ qbool loadcsqc;
+ qbool loadbegun;
+ qbool loadfinished;
// quakeworld stuff
// unused: indicates whether the player is spectating
// use cl.scores[cl.playerentity-1].qw_spectator instead
- //qboolean qw_spectator;
+ //qbool qw_spectator;
- // last time an input packet was sent
- double lastpackettime;
+ // time accumulated since an input packet was sent
+ float timesincepacket;
+ // how many optimally timed inputs we sent since we received an update from the server
+ uint8_t opt_inputs_since_update;
// movement parameters for client prediction
+ unsigned int moveflags;
float movevars_wallfriction;
float movevars_waterfriction;
float movevars_friction;
float movevars_maxairspeed;
float movevars_stepheight;
float movevars_airaccel_qw;
+ float movevars_airaccel_qw_stretchfactor;
float movevars_airaccel_sideways_friction;
float movevars_airstopaccelerate;
float movevars_airstrafeaccelerate;
float movevars_maxairstrafespeed;
+ float movevars_airstrafeaccel_qw;
float movevars_aircontrol;
+ float movevars_aircontrol_power;
+ float movevars_aircontrol_penalty;
float movevars_warsowbunny_airforwardaccel;
float movevars_warsowbunny_accel;
float movevars_warsowbunny_topspeed;
float movevars_warsowbunny_turnaccel;
float movevars_warsowbunny_backtosideratio;
+ float movevars_ticrate;
+ float movevars_airspeedlimit_nonqw;
// models used by qw protocol
int qw_modelindex_spike;
float qw_weaponkick;
- int qw_validsequence;
+ unsigned int qw_validsequence;
- int qw_deltasequence[QW_UPDATE_BACKUP];
+ unsigned 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;
+ qbool csqc_loaded;
+ vec3_t csqc_vieworigin;
+ vec3_t csqc_viewangles;
+ vec3_t csqc_vieworiginfromengine;
+ vec3_t csqc_viewanglesfromengine;
+ matrix4x4_t csqc_viewmodelmatrixfromengine;
+ qbool csqc_usecsqclistener;
matrix4x4_t csqc_listenermatrix;
char csqc_printtextbuf[MAX_INPUTLINE];
// freed on each level change
size_t buildlightmapmemorysize;
unsigned char *buildlightmapmemory;
+
+ // used by EntityState5_ReadUpdate
+ skeleton_t *engineskeletonobjects;
}
client_state_t;
extern cvar_t cl_name;
extern cvar_t cl_color;
extern cvar_t cl_rate;
+extern cvar_t cl_rate_burstsize;
extern cvar_t cl_pmodel;
extern cvar_t cl_playermodel;
extern cvar_t cl_playerskin;
extern cvar_t cl_autofire;
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_autodemo;
extern cvar_t cl_autodemo_nameformat;
+extern cvar_t cl_autodemo_delete;
extern cvar_t r_draweffects;
extern cvar_t cl_stainmaps_clearonload;
extern cvar_t cl_prydoncursor;
+extern cvar_t cl_prydoncursor_notrace;
extern cvar_t cl_locs_enable;
+extern cvar_t cl_areagrid_link_SOLID_NOT;
+
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);
+extern 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);
cl_locnode_t *CL_Locs_FindNearest(const vec3_t point);
void CL_Locs_FindLocationName(char *buffer, size_t buffersize, vec3_t point);
// cl_main
//
+double CL_Frame(double time);
+
void CL_Shutdown (void);
void CL_Init (void);
-void CL_EstablishConnection(const char *host);
+void CL_StartVideo(void);
+
+void CL_EstablishConnection(const char *host, int firstarg);
-void CL_Disconnect (void);
-void CL_Disconnect_f (void);
+void CL_Disconnect(void);
+void CL_DisconnectEx(qbool kicked, const char *reason, ... );
+void CL_Disconnect_f(cmd_state_t *cmd);
void CL_UpdateRenderEntity(entity_render_t *ent);
void CL_SetEntityColormapColors(entity_render_t *ent, int colormap);
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_NewBeam (int ent, vec3_t start, vec3_t end, 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_render_t *CL_NewTempEntity (double shadertime);
-void CL_Effect(vec3_t org, int modelindex, int startframe, int framecount, float framerate);
+void CL_Effect(vec3_t org, model_t *model, 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);
+void CL_ExpandCSQCRenderEntities(int num);
+void CL_SetInfo(const char *key, const char *value, qbool send, qbool allowstarkey, qbool allowmodel, qbool quiet);
void CL_UpdateWorld (void);
float CL_KeyState (kbutton_t *key);
-const char *Key_KeynumToString (int keynum);
-int Key_StringToKeynum (const char *str);
+
+//
+// cl_cmd.c
+//
+/// 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)
+void CL_ForwardToServer (const char *s);
+
+/// 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.
+void CL_ForwardToServer_f (cmd_state_t *cmd);
+void CL_InitCommands(void);
+
//
// cl_demo.c
void CL_CutDemo(unsigned char **buf, fs_offset_t *filesize);
void CL_PasteDemo(unsigned char **buf, fs_offset_t *filesize);
+void CL_PlayDemo(const char *demo);
void CL_NextDemo(void);
-void CL_Stop_f(void);
-void CL_Record_f(void);
-void CL_PlayDemo_f(void);
-void CL_TimeDemo_f(void);
-
-//
-// cl_parse.c
-//
-void CL_Parse_Init(void);
-void CL_Parse_Shutdown(void);
-void CL_ParseServerMessage(void);
-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
-//
-void V_StartPitchDrift (void);
-void V_StopPitchDrift (void);
+void CL_Stop_f(cmd_state_t *cmd);
+void CL_Record_f(cmd_state_t *cmd);
+void CL_PlayDemo_f(cmd_state_t *cmd);
+void CL_TimeDemo_f(cmd_state_t *cmd);
-void V_Init (void);
-float V_CalcRoll (vec3_t angles, vec3_t velocity);
-void V_UpdateBlends (void);
-void V_ParseDamage (void);
+void CL_Demo_Init(void);
-//
-// cl_part
-//
-
-extern cvar_t cl_particles;
-extern cvar_t cl_particles_quality;
-extern cvar_t cl_particles_size;
-extern cvar_t cl_particles_quake;
-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_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;
-extern cvar_t cl_particles_sparks;
-extern cvar_t cl_particles_bubbles;
-extern cvar_t cl_decals;
-extern cvar_t cl_decals_time;
-extern cvar_t cl_decals_fadetime;
-
-void CL_Particles_Clear(void);
-void CL_Particles_Init(void);
-void CL_Particles_Shutdown(void);
-
-typedef enum effectnameindex_s
-{
- EFFECT_NONE,
- EFFECT_TE_GUNSHOT,
- EFFECT_TE_GUNSHOTQUAD,
- EFFECT_TE_SPIKE,
- EFFECT_TE_SPIKEQUAD,
- EFFECT_TE_SUPERSPIKE,
- EFFECT_TE_SUPERSPIKEQUAD,
- EFFECT_TE_WIZSPIKE,
- EFFECT_TE_KNIGHTSPIKE,
- EFFECT_TE_EXPLOSION,
- EFFECT_TE_EXPLOSIONQUAD,
- EFFECT_TE_TAREXPLOSION,
- EFFECT_TE_TELEPORT,
- EFFECT_TE_LAVASPLASH,
- EFFECT_TE_SMALLFLASH,
- EFFECT_TE_FLAMEJET,
- EFFECT_EF_FLAME,
- EFFECT_TE_BLOOD,
- EFFECT_TE_SPARK,
- EFFECT_TE_PLASMABURN,
- EFFECT_TE_TEI_G3,
- EFFECT_TE_TEI_SMOKE,
- EFFECT_TE_TEI_BIGEXPLOSION,
- EFFECT_TE_TEI_PLASMAHIT,
- EFFECT_EF_STARDUST,
- EFFECT_TR_ROCKET,
- EFFECT_TR_GRENADE,
- EFFECT_TR_BLOOD,
- EFFECT_TR_WIZSPIKE,
- EFFECT_TR_SLIGHTBLOOD,
- EFFECT_TR_KNIGHTSPIKE,
- EFFECT_TR_VORESPIKE,
- EFFECT_TR_NEHAHRASMOKE,
- EFFECT_TR_NEXUIZPLASMA,
- EFFECT_TR_GLOWTRAIL,
- EFFECT_SVC_PARTICLE,
- EFFECT_TOTAL
-}
-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 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"
-extern qboolean sb_showscores;
-
-float FogPoint_World(const vec3_t p);
-float FogPoint_Model(const vec3_t p);
-float FogForDistance(vec_t dist);
+extern qbool sb_showscores;
-typedef struct r_refdef_stats_s
+typedef enum waterlevel_e
{
- 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;
+ WATERLEVEL_NONE,
+ WATERLEVEL_WETFEET,
+ WATERLEVEL_SWIMMING,
+ WATERLEVEL_SUBMERGED
}
-r_refdef_stats_t;
+waterlevel_t;
-typedef struct r_refdef_view_s
+typedef struct cl_clientmovement_state_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)
-
- // eye position information
- matrix4x4_t matrix, inverse_matrix;
+ // entity to be ignored for movement
+ struct prvm_edict_s *self;
+ // position
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];
-
- // 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
- double time;
-
- // the world
- entity_render_t *worldentity;
-
- // same as worldentity->model
- 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 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 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;
+ vec3_t velocity;
+ // current bounding box (different if crouched vs standing)
+ vec3_t mins;
+ vec3_t maxs;
+ // currently on the ground
+ qbool onground;
+ // currently crouching
+ qbool crouched;
+ // what kind of water (SUPERCONTENTS_LAVA for instance)
+ int watertype;
+ // how deep
+ waterlevel_t waterlevel;
+ // weird hacks when jumping out of water
+ // (this is in seconds and counts down to 0)
+ float waterjumptime;
+
+ // user command
+ usercmd_t cmd;
}
-r_refdef_t;
-
-extern r_refdef_t r_refdef;
+cl_clientmovement_state_t;
+void CL_ClientMovement_PlayerMove_Frame(cl_clientmovement_state_t *s);
+
+// warpzone prediction hack (CSQC builtin)
+void CL_RotateMoves(const matrix4x4_t *m);
+
+typedef enum meshname_e {
+ MESH_SCENE, // CSQC R_PolygonBegin, potentially also engine particles and debug stuff
+ MESH_UI,
+ NUM_MESHENTITIES,
+} meshname_t;
+extern entity_t cl_meshentities[NUM_MESHENTITIES];
+extern model_t cl_meshentitymodels[NUM_MESHENTITIES];
+extern const char *cl_meshentitynames[NUM_MESHENTITIES];
+#define CL_Mesh_Scene() (&cl_meshentitymodels[MESH_SCENE])
+#define CL_Mesh_UI() (&cl_meshentitymodels[MESH_UI])
+void CL_MeshEntities_Init(void);
+void CL_MeshEntities_Scene_Clear(void);
+void CL_MeshEntities_Scene_AddRenderEntity(void);
+void CL_MeshEntities_Scene_FinalizeRenderEntity(void);
+void CL_UpdateEntityShading(void);
+
+void CL_NewFrameReceived(int num);
+void CL_ParseEntityLump(char *entitystring);
+void CL_FindNonSolidLocation(const vec3_t in, vec3_t out, vec_t radius);
+void CL_RelinkLightFlashes(void);
+void CL_Beam_AddPolygons(const beam_t *b);
+void CL_UpdateMoveVars(void);
+void CL_Locs_Reload_f(cmd_state_t *cmd);
#endif