Fix engine not starting on Windows if linked against SDL > 2.0.5
[xonotic/darkplaces.git] / client.h
index 0794530..17cce99 100644 (file)
--- a/client.h
+++ b/client.h
@@ -25,6 +25,171 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "matrixlib.h"
 #include "snd_main.h"
 
+// NOTE: r_stat_name[] must match this indexing
+typedef enum r_stat_e
+{
+       r_stat_timedelta,
+       r_stat_quality,
+       r_stat_renders,
+       r_stat_entities,
+       r_stat_entities_surfaces,
+       r_stat_entities_triangles,
+       r_stat_world_leafs,
+       r_stat_world_portals,
+       r_stat_world_surfaces,
+       r_stat_world_triangles,
+       r_stat_lightmapupdates,
+       r_stat_lightmapupdatepixels,
+       r_stat_particles,
+       r_stat_drawndecals,
+       r_stat_totaldecals,
+       r_stat_draws,
+       r_stat_draws_vertices,
+       r_stat_draws_elements,
+       r_stat_lights,
+       r_stat_lights_clears,
+       r_stat_lights_scissored,
+       r_stat_lights_lighttriangles,
+       r_stat_lights_shadowtriangles,
+       r_stat_lights_dynamicshadowtriangles,
+       r_stat_bouncegrid_lights,
+       r_stat_bouncegrid_particles,
+       r_stat_bouncegrid_traces,
+       r_stat_bouncegrid_hits,
+       r_stat_bouncegrid_splats,
+       r_stat_bouncegrid_bounces,
+       r_stat_photoncache_animated,
+       r_stat_photoncache_cached,
+       r_stat_photoncache_traced,
+       r_stat_bloom,
+       r_stat_bloom_copypixels,
+       r_stat_bloom_drawpixels,
+       r_stat_rendertargets_used,
+       r_stat_rendertargets_pixels,
+       r_stat_indexbufferuploadcount,
+       r_stat_indexbufferuploadsize,
+       r_stat_vertexbufferuploadcount,
+       r_stat_vertexbufferuploadsize,
+       r_stat_framedatacurrent,
+       r_stat_framedatasize,
+       r_stat_bufferdatacurrent_vertex, // R_BUFFERDATA_ types are added to this index
+       r_stat_bufferdatacurrent_index16,
+       r_stat_bufferdatacurrent_index32,
+       r_stat_bufferdatacurrent_uniform,
+       r_stat_bufferdatasize_vertex, // R_BUFFERDATA_ types are added to this index
+       r_stat_bufferdatasize_index16,
+       r_stat_bufferdatasize_index32,
+       r_stat_bufferdatasize_uniform,
+       r_stat_animcache_skeletal_count,
+       r_stat_animcache_skeletal_bones,
+       r_stat_animcache_skeletal_maxbones,
+       r_stat_animcache_shade_count,
+       r_stat_animcache_shade_vertices,
+       r_stat_animcache_shade_maxvertices,
+       r_stat_animcache_shape_count,
+       r_stat_animcache_shape_vertices,
+       r_stat_animcache_shape_maxvertices,
+       r_stat_batch_batches,
+       r_stat_batch_withgaps,
+       r_stat_batch_surfaces,
+       r_stat_batch_vertices,
+       r_stat_batch_triangles,
+       r_stat_batch_fast_batches,
+       r_stat_batch_fast_surfaces,
+       r_stat_batch_fast_vertices,
+       r_stat_batch_fast_triangles,
+       r_stat_batch_copytriangles_batches,
+       r_stat_batch_copytriangles_surfaces,
+       r_stat_batch_copytriangles_vertices,
+       r_stat_batch_copytriangles_triangles,
+       r_stat_batch_dynamic_batches,
+       r_stat_batch_dynamic_surfaces,
+       r_stat_batch_dynamic_vertices,
+       r_stat_batch_dynamic_triangles,
+       r_stat_batch_dynamicskeletal_batches,
+       r_stat_batch_dynamicskeletal_surfaces,
+       r_stat_batch_dynamicskeletal_vertices,
+       r_stat_batch_dynamicskeletal_triangles,
+       r_stat_batch_dynamic_batches_because_cvar,
+       r_stat_batch_dynamic_surfaces_because_cvar,
+       r_stat_batch_dynamic_vertices_because_cvar,
+       r_stat_batch_dynamic_triangles_because_cvar,
+       r_stat_batch_dynamic_batches_because_lightmapvertex,
+       r_stat_batch_dynamic_surfaces_because_lightmapvertex,
+       r_stat_batch_dynamic_vertices_because_lightmapvertex,
+       r_stat_batch_dynamic_triangles_because_lightmapvertex,
+       r_stat_batch_dynamic_batches_because_deformvertexes_autosprite,
+       r_stat_batch_dynamic_surfaces_because_deformvertexes_autosprite,
+       r_stat_batch_dynamic_vertices_because_deformvertexes_autosprite,
+       r_stat_batch_dynamic_triangles_because_deformvertexes_autosprite,
+       r_stat_batch_dynamic_batches_because_deformvertexes_autosprite2,
+       r_stat_batch_dynamic_surfaces_because_deformvertexes_autosprite2,
+       r_stat_batch_dynamic_vertices_because_deformvertexes_autosprite2,
+       r_stat_batch_dynamic_triangles_because_deformvertexes_autosprite2,
+       r_stat_batch_dynamic_batches_because_deformvertexes_normal,
+       r_stat_batch_dynamic_surfaces_because_deformvertexes_normal,
+       r_stat_batch_dynamic_vertices_because_deformvertexes_normal,
+       r_stat_batch_dynamic_triangles_because_deformvertexes_normal,
+       r_stat_batch_dynamic_batches_because_deformvertexes_wave,
+       r_stat_batch_dynamic_surfaces_because_deformvertexes_wave,
+       r_stat_batch_dynamic_vertices_because_deformvertexes_wave,
+       r_stat_batch_dynamic_triangles_because_deformvertexes_wave,
+       r_stat_batch_dynamic_batches_because_deformvertexes_bulge,
+       r_stat_batch_dynamic_surfaces_because_deformvertexes_bulge,
+       r_stat_batch_dynamic_vertices_because_deformvertexes_bulge,
+       r_stat_batch_dynamic_triangles_because_deformvertexes_bulge,
+       r_stat_batch_dynamic_batches_because_deformvertexes_move,
+       r_stat_batch_dynamic_surfaces_because_deformvertexes_move,
+       r_stat_batch_dynamic_vertices_because_deformvertexes_move,
+       r_stat_batch_dynamic_triangles_because_deformvertexes_move,
+       r_stat_batch_dynamic_batches_because_tcgen_lightmap,
+       r_stat_batch_dynamic_surfaces_because_tcgen_lightmap,
+       r_stat_batch_dynamic_vertices_because_tcgen_lightmap,
+       r_stat_batch_dynamic_triangles_because_tcgen_lightmap,
+       r_stat_batch_dynamic_batches_because_tcgen_vector,
+       r_stat_batch_dynamic_surfaces_because_tcgen_vector,
+       r_stat_batch_dynamic_vertices_because_tcgen_vector,
+       r_stat_batch_dynamic_triangles_because_tcgen_vector,
+       r_stat_batch_dynamic_batches_because_tcgen_environment,
+       r_stat_batch_dynamic_surfaces_because_tcgen_environment,
+       r_stat_batch_dynamic_vertices_because_tcgen_environment,
+       r_stat_batch_dynamic_triangles_because_tcgen_environment,
+       r_stat_batch_dynamic_batches_because_tcmod_turbulent,
+       r_stat_batch_dynamic_surfaces_because_tcmod_turbulent,
+       r_stat_batch_dynamic_vertices_because_tcmod_turbulent,
+       r_stat_batch_dynamic_triangles_because_tcmod_turbulent,
+       r_stat_batch_dynamic_batches_because_nogaps,
+       r_stat_batch_dynamic_surfaces_because_nogaps,
+       r_stat_batch_dynamic_vertices_because_nogaps,
+       r_stat_batch_dynamic_triangles_because_nogaps,
+       r_stat_batch_dynamic_batches_because_derived,
+       r_stat_batch_dynamic_surfaces_because_derived,
+       r_stat_batch_dynamic_vertices_because_derived,
+       r_stat_batch_dynamic_triangles_because_derived,
+       r_stat_batch_entitycache_count,
+       r_stat_batch_entitycache_surfaces,
+       r_stat_batch_entitycache_vertices,
+       r_stat_batch_entitycache_triangles,
+       r_stat_batch_entityanimate_count,
+       r_stat_batch_entityanimate_surfaces,
+       r_stat_batch_entityanimate_vertices,
+       r_stat_batch_entityanimate_triangles,
+       r_stat_batch_entityskeletal_count,
+       r_stat_batch_entityskeletal_surfaces,
+       r_stat_batch_entityskeletal_vertices,
+       r_stat_batch_entityskeletal_triangles,
+       r_stat_batch_entitystatic_count,
+       r_stat_batch_entitystatic_surfaces,
+       r_stat_batch_entitystatic_vertices,
+       r_stat_batch_entitystatic_triangles,
+       r_stat_batch_entitycustom_count,
+       r_stat_batch_entitycustom_surfaces,
+       r_stat_batch_entitycustom_vertices,
+       r_stat_batch_entitycustom_triangles,
+       r_stat_count // size of array
+}
+r_stat_t;
+
 // flags for rtlight rendering
 #define LIGHTFLAG_NORMALMODE 1
 #define LIGHTFLAG_REALTIMEMODE 2
@@ -34,7 +199,8 @@ typedef struct tridecal_s
        // color and initial alpha value
        float                   texcoord2f[3][2];
        float                   vertex3f[3][3];
-       unsigned char   color4ub[3][4];
+       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
@@ -42,7 +208,7 @@ typedef struct tridecal_s
        // for visibility culling
        int                             surfaceindex;
        // old decals are killed to obey cl_decals_max
-       int                             decalsequence;
+       unsigned int    decalsequence;
 }
 tridecal_t;
 
@@ -89,10 +255,15 @@ typedef struct beam_s
 }
 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
@@ -108,7 +279,7 @@ typedef struct rtlight_s
        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;
@@ -124,15 +295,13 @@ typedef struct rtlight_s
        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
@@ -141,10 +310,12 @@ typedef struct rtlight_s
        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
        qboolean draw;
+       /// set by R_Shadow_PrepareLight to indicate whether R_Shadow_DrawShadowMaps should do anything
+       qboolean castshadows;
        /// these fields are set by R_Shadow_PrepareLight for later drawing
        int cached_numlightentities;
        int cached_numlightentities_noselfshadow;
@@ -174,9 +345,13 @@ typedef struct rtlight_s
        int compiled;
        /// the shadowing mode used to compile this light
        int shadowmode;
-       /// 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;
@@ -202,6 +377,18 @@ typedef struct rtlight_s
        /// 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;
 
@@ -278,18 +465,6 @@ typedef struct dlight_s
 }
 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
@@ -364,15 +539,58 @@ typedef struct entity_render_s
 
        // animation cache (pointers allocated using R_FrameData_Alloc)
        // ONLY valid during R_RenderView!  may be NULL (not cached)
-       float *animcache_vertex3f;
-       float *animcache_normal3f;
-       float *animcache_svector3f;
-       float *animcache_tvector3f;
-
-       // 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
+       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[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 lightgrid on this entity (e.g. FULLBRIGHT)
+       qboolean render_modellight_forced;
+       // do not process per pixel lights on this entity at all (like MATERIALFLAG_NORTLIGHT)
+       qboolean render_rtlight_disabled;
 
        // storage of decals on this entity
        // (note: if allowdecals is set, be sure to call R_DecalSystem_Reset on removal!)
@@ -382,31 +600,24 @@ typedef struct entity_render_s
        // 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;
+       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)
        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];
 }
 entity_persistent_t;
 
@@ -450,7 +661,7 @@ typedef struct usercmd_s
        int msec; // for predicted moves
        int buttons;
        int impulse;
-       int sequence;
+       unsigned int sequence;
        qboolean applied; // if false we're still accumulating a move
        qboolean predicted; // if true the sequence should be sent as 0
 
@@ -529,7 +740,7 @@ qw_downloadtype_t;
 typedef enum capturevideoformat_e
 {
        CAPTUREVIDEOFORMAT_AVI_I420,
-       CAPTUREVIDEOFORMAT_OGG_VORBIS_THEORA,
+       CAPTUREVIDEOFORMAT_OGG_VORBIS_THEORA
 }
 capturevideoformat_t;
 
@@ -568,7 +779,7 @@ typedef struct capturevideostate_s
        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);
+               //   cls.capturevideo.videofile = FS_OpenRealFile(va(vabuf, sizeof(vabuf), "%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);
@@ -620,6 +831,7 @@ typedef struct client_static_s
        fs_offset_t demo_lastcsprogssize;
        int demo_lastcsprogscrc;
        qboolean demoplayback;
+       qboolean demostarting; // set if currently starting a demo, to stop -demo from quitting when switching to another demo
        qboolean timedemo;
        // -1 = use normal cd track
        int forcetrack;
@@ -645,6 +857,7 @@ typedef struct client_static_s
        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;
@@ -667,16 +880,15 @@ typedef struct client_static_s
        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];
@@ -702,26 +914,36 @@ typedef struct client_static_s
        // 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];
+
        // video capture stuff
        capturevideostate_t capturevideo;
+
+       // crypto channel
+       crypto_t crypto;
+
+       // 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)
+
+       // don't write-then-read csprogs.dat (useful for demo playback)
+       unsigned char *caughtcsprogsdata;
+       fs_offset_t caughtcsprogsdatasize;
+
+       int r_speeds_graph_length;
+       int r_speeds_graph_current;
+       int *r_speeds_graph_data;
+
+       // graph scales
+       int r_speeds_graph_datamin[r_stat_count];
+       int r_speeds_graph_datamax[r_stat_count];
 }
 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;
-
 //[515]: csqc
 typedef struct
 {
@@ -758,7 +980,7 @@ typedef struct particletype_s
 }
 particletype_t;
 
-typedef enum
+typedef enum ptype_e
 {
        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
 }
@@ -769,7 +991,7 @@ typedef struct decal_s
        // fields used by rendering:  (44 bytes)
        unsigned short  typeindex;
        unsigned short  texnum;
-       int                             decalsequence;
+       unsigned int    decalsequence;
        vec3_t                  org;
        vec3_t                  normal;
        float                   size;
@@ -789,33 +1011,43 @@ decal_t;
 
 typedef struct particle_s
 {
-       // fields used by rendering: (40 bytes)
+       // for faster batch rendering, particles are rendered in groups by effect (resulting in less perfect sorting but far less state changes)
+
+       // fields used by rendering: (48 bytes)
+       vec3_t          sortorigin; // sort by this group origin, not particle org
+       vec3_t          org;
+       vec3_t          vel; // velocity of particle, or orientation of decal, or end point of beam
+       float           size;
+       float           alpha; // 0-255
+       float           stretch; // only for sparks
+
+       // fields not used by rendering:  (44 bytes)
+       float           stainsize;
+       float           stainalpha;
+       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
+
+       // short variables grouped to save memory (4 bytes)
+       short                   angle; // base rotation of particle
+       short                   spin; // geometry rotation speed around the particle center normal
+
+       // byte variables grouped to save memory (12 bytes)
+       unsigned char   color[3];
+       unsigned char   qualityreduction; // enables skipping of this particle according to r_refdef.view.qualityreduction
        unsigned char   typeindex;
-       pblend_t   blendmode;
-       porientation_t   orientation;
+       unsigned char   blendmode;
+       unsigned char   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;
+       unsigned char   staincolor[3];
        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;
 
@@ -922,6 +1154,17 @@ typedef struct client_state_s
        // whether the replay should allow a jump at the first sequence
        qboolean 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;
@@ -933,6 +1176,7 @@ typedef struct client_state_s
        float sensitivityscale;
        csqc_vidvars_t csqc_vidvars;    //[515]: these parms must be set to true by default
        qboolean csqc_wantsmousemove;
+       qboolean csqc_paused; // vortex: int because could be flags
        struct model_s *csqc_model_precache[MAX_MODELS];
 
        // local amount for smoothing stepups
@@ -947,6 +1191,10 @@ typedef struct client_state_s
        qboolean 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;
@@ -984,7 +1232,11 @@ typedef struct client_state_s
        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,
@@ -1046,7 +1298,7 @@ typedef struct client_state_s
 #define LATESTFRAMENUMS 32
        int latestframenumsposition;
        int latestframenums[LATESTFRAMENUMS];
-       int latestsendnums[LATESTFRAMENUMS];
+       unsigned int latestsendnums[LATESTFRAMENUMS];
        entityframe_database_t *entitydatabase;
        entityframe4_database_t *entitydatabase4;
        entityframeqw_database_t *entitydatabaseqw;
@@ -1062,7 +1314,7 @@ typedef struct client_state_s
        vec3_t playercrouchmaxs;
 
        // old decals are killed based on this
-       int decalsequence;
+       unsigned int decalsequence;
 
        int max_entities;
        int max_csqcrenderentities;
@@ -1156,17 +1408,22 @@ typedef struct client_state_s
        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;
@@ -1183,16 +1440,19 @@ typedef struct client_state_s
 
        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;
+       vec3_t csqc_vieworigin;
+       vec3_t csqc_viewangles;
+       vec3_t csqc_vieworiginfromengine;
+       vec3_t csqc_viewanglesfromengine;
+       matrix4x4_t csqc_viewmodelmatrixfromengine;
        qboolean csqc_usecsqclistener;
        matrix4x4_t csqc_listenermatrix;
        char csqc_printtextbuf[MAX_INPUTLINE];
@@ -1210,6 +1470,9 @@ typedef struct client_state_s
        // freed on each level change
        size_t buildlightmapmemorysize;
        unsigned char *buildlightmapmemory;
+
+       // used by EntityState5_ReadUpdate
+       skeleton_t *engineskeletonobjects;
 }
 client_state_t;
 
@@ -1219,6 +1482,7 @@ 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;
@@ -1260,6 +1524,7 @@ extern cvar_t m_side;
 
 extern cvar_t cl_autodemo;
 extern cvar_t cl_autodemo_nameformat;
+extern cvar_t cl_autodemo_delete;
 
 extern cvar_t r_draweffects;
 
@@ -1272,6 +1537,7 @@ extern cvar_t cl_stainmaps;
 extern cvar_t cl_stainmaps_clearonload;
 
 extern cvar_t cl_prydoncursor;
+extern cvar_t cl_prydoncursor_notrace;
 
 extern cvar_t cl_locs_enable;
 
@@ -1291,7 +1557,7 @@ void CL_Locs_FindLocationName(char *buffer, size_t buffersize, vec3_t point);
 void CL_Shutdown (void);
 void CL_Init (void);
 
-void CL_EstablishConnection(const char *host);
+void CL_EstablishConnection(const char *host, int firstarg);
 
 void CL_Disconnect (void);
 void CL_Disconnect_f (void);
@@ -1344,7 +1610,7 @@ extern int cl_ignoremousemoves;
 
 
 float CL_KeyState (kbutton_t *key);
-const char *Key_KeynumToString (int keynum);
+const char *Key_KeynumToString (int keynum, char *buf, size_t buflength);
 int Key_StringToKeynum (const char *str);
 
 //
@@ -1382,7 +1648,7 @@ void V_StartPitchDrift (void);
 void V_StopPitchDrift (void);
 
 void V_Init (void);
-float V_CalcRoll (vec3_t angles, vec3_t velocity);
+float V_CalcRoll (const vec3_t angles, const vec3_t velocity);
 void V_UpdateBlends (void);
 void V_ParseDamage (void);
 
@@ -1396,6 +1662,9 @@ 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_decal_alpha;
+extern cvar_t cl_particles_blood_decal_scalemin;
+extern cvar_t cl_particles_blood_decal_scalemax;
 extern cvar_t cl_particles_blood_bloodhack;
 extern cvar_t cl_particles_bulletimpacts;
 extern cvar_t cl_particles_explosions_sparks;
@@ -1414,7 +1683,7 @@ extern cvar_t cl_decals_fadetime;
 void CL_Particles_Clear(void);
 void CL_Particles_Init(void);
 void CL_Particles_Shutdown(void);
-particle_t *CL_NewParticle(unsigned short ptypeindex, int pcolor1, int pcolor2, int ptex, float psize, float psizeincrease, float palpha, float palphafade, float pgravity, float pbounce, float px, float py, float pz, float pvx, float pvy, float pvz, float pairfriction, float pliquidfriction, float originjitter, float velocityjitter, qboolean pqualityreduction, float lifetime, float stretch, pblend_t blendmode, porientation_t orientation, int staincolor1, int staincolor2, int staintex);
+particle_t *CL_NewParticle(const vec3_t sortorigin, unsigned short ptypeindex, int pcolor1, int pcolor2, int ptex, float psize, float psizeincrease, float palpha, float palphafade, float pgravity, float pbounce, float px, float py, float pz, float pvx, float pvy, float pvz, float pairfriction, float pliquidfriction, float originjitter, float velocityjitter, qboolean pqualityreduction, float lifetime, float stretch, pblend_t blendmode, porientation_t orientation, int staincolor1, int staincolor2, int staintex, float stainalpha, float stainsize, float angle, float spin, float tint[4]);
 
 typedef enum effectnameindex_s
 {
@@ -1461,7 +1730,8 @@ 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_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, float tintmins[4], float tintmaxs[4], float fade);
+void CL_ParticleBox(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, float tintmins[4], float tintmaxs[4], float fade);
 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);
@@ -1470,10 +1740,6 @@ 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;
@@ -1481,35 +1747,6 @@ extern qboolean sb_showscores;
 float RSurf_FogVertex(const vec3_t p);
 float RSurf_FogPoint(const vec3_t p);
 
-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 drawndecals;
-       int totaldecals;
-       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;
-
 typedef enum r_viewport_type_e
 {
        R_VIEWPORTTYPE_ORTHO,
@@ -1563,6 +1800,12 @@ typedef struct r_refdef_view_s
        vec3_t frustumcorner[4];
        // if turned off it renders an ortho view
        int useperspective;
+       // allows visibility culling based on the view origin (e.g. pvs and R_CanSeeBox)
+       // this is turned off by:
+       // r_trippy
+       // !r_refdef.view.useperspective
+       // (sometimes) r_refdef.view.useclipplane
+       int usevieworiginculling;
        float ortho_x, ortho_y;
 
        // screen area to render in
@@ -1572,21 +1815,23 @@ typedef struct r_refdef_view_s
        int width;
        int height;
        int depth;
-       r_viewport_t viewport;
+       r_viewport_t viewport; // note: if r_viewscale is used, the viewport.width and viewport.height may be less than width and height
 
        // which color components to allow (for anaglyph glasses)
        int colormask[4];
 
-       // global RGB color multiplier for rendering, this is required by HDR
+       // global RGB color multiplier for rendering
        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;
+       // if true, this is the MAIN view (which is, after CSQC, copied into the scene for use e.g. by r_speeds 1, showtex, prydon cursor)
+       qboolean ismain;
 
        // whether to draw r_showtris and such, this is only true for the main
-       // view render, all secondary renders (HDR, mirrors, portals, cameras,
+       // view render, all secondary renders (mirrors, portals, cameras,
        // distortion effects, etc) omit such debugging information
        qboolean showdebug;
 
@@ -1648,6 +1893,7 @@ typedef struct r_refdef_scene_s {
        entity_render_t *tempentities;
        int numtempentities;
        int maxtempentities;
+       qboolean expandtempentities;
 
        // renderable dynamic lights
        rtlight_t *lights[MAX_DLIGHTS];
@@ -1660,7 +1906,12 @@ typedef struct r_refdef_scene_s {
        // controls intensity lightmap layers
        unsigned short lightstylevalue[MAX_LIGHTSTYLES];        // 8.8 fraction of base light value
 
-       float ambient;
+       // adds brightness to the whole scene, separate from lightmapintensity
+       // see CL_UpdateEntityShading
+       float ambientintensity;
+       // brightness of lightmap and modellight lighting on materials
+       // see CL_UpdateEntityShading
+       float lightmapintensity;
 
        qboolean rtworld;
        qboolean rtworldshadows;
@@ -1716,27 +1967,110 @@ typedef struct r_refdef_s
        qboolean fogenabled;
        qboolean oldgl_fogenable;
 
-       qboolean draw2dstage;
+       // new flexible texture height fog (overrides normal fog)
+       char fog_height_texturename[64]; // note: must be 64 for the sscanf code
+       unsigned char *fog_height_table1d;
+       unsigned char *fog_height_table2d;
+       int fog_height_tablesize; // enable
+       float fog_height_tablescale;
+       float fog_height_texcoordscale;
+       char fogheighttexturename[64]; // detects changes to active fog height texture
+
+       int draw2dstage; // 0 = no, 1 = yes, other value = needs setting up again
 
        // 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;
+
+       // how long R_RenderView took on the previous frame
+       double lastdrawscreentime;
 
        // rendering stats for r_speeds display
        // (these are incremented in many places)
-       r_refdef_stats_t stats;
+       int stats[r_stat_count];
 }
 r_refdef_t;
 
 extern r_refdef_t r_refdef;
 
+typedef enum waterlevel_e
+{
+       WATERLEVEL_NONE,
+       WATERLEVEL_WETFEET,
+       WATERLEVEL_SWIMMING,
+       WATERLEVEL_SUBMERGED
+}
+waterlevel_t;
+
+typedef struct cl_clientmovement_state_s
+{
+       // entity to be ignored for movement
+       struct prvm_edict_s *self;
+       // position
+       vec3_t origin;
+       vec3_t velocity;
+       // current bounding box (different if crouched vs standing)
+       vec3_t mins;
+       vec3_t maxs;
+       // currently on the ground
+       qboolean onground;
+       // currently crouching
+       qboolean 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;
+}
+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_DEBUG,
+       MESH_CSQCPOLYGONS,
+       MESH_PARTICLES,
+       MESH_UI,
+       NUM_MESHENTITIES,
+} meshname_t;
+extern entity_t cl_meshentities[NUM_MESHENTITIES];
+extern dp_model_t cl_meshentitymodels[NUM_MESHENTITIES];
+extern const char *cl_meshentitynames[NUM_MESHENTITIES];
+#define CL_Mesh_Debug() (&cl_meshentitymodels[MESH_DEBUG])
+#define CL_Mesh_CSQC() (&cl_meshentitymodels[MESH_CSQCPOLYGONS])
+#define CL_Mesh_Particles() (&cl_meshentitymodels[MESH_PARTICLES])
+#define CL_Mesh_UI() (&cl_meshentitymodels[MESH_UI])
+void CL_MeshEntities_AddToScene(void);
+void CL_MeshEntities_Reset(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 Sbar_ShowFPS(void);
+void Sbar_ShowFPS_Update(void);
+void Host_SaveConfig(void);
+void Host_LoadConfig_f(void);
+void CL_UpdateMoveVars(void);
+void SCR_CaptureVideo_SoundFrame(const portable_sampleframe_t *paintbuffer, size_t length);
+void V_DriftPitch(void);
+void V_FadeViewFlashs(void);
+void V_CalcViewBlend(void);
+void V_CalcRefdefUsing (const matrix4x4_t *entrendermatrix, const vec3_t clviewangles, qboolean teleported, qboolean clonground, qboolean clcmdjump, float clstatsviewheight, qboolean cldead, qboolean clintermission, const vec3_t clvelocity);
+void V_CalcRefdef(void);
+void CL_Locs_Reload_f(void);
+
 #endif