client.h

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20 // client.h
  21
  22 #ifndef CLIENT_H
  23 #define CLIENT_H
  24
  25 #include "matrixlib.h"
  26 #include "snd_main.h"
  27 #include "view.h"
  28 #include "cap.h"
  29 #include "cl_parse.h"
  30 #include "cl_particles.h"
  31 #include "r_stats.h"
  32
  33 // flags for rtlight rendering
  34 #define LIGHTFLAG_NORMALMODE 1
  35 #define LIGHTFLAG_REALTIMEMODE 2
  36
  37 typedef struct tridecal_s
  38 {
  39         // color and initial alpha value
  40         float                   texcoord2f[3][2];
  41         float                   vertex3f[3][3];
  42         float                   color4f[3][4];
  43         float                   plane[4]; // backface culling
  44         // how long this decal has lived so far (the actual fade begins at cl_decals_time)
  45         float                   lived;
  46         // if >= 0 this indicates the decal should follow an animated triangle
  47         int                             triangleindex;
  48         // for visibility culling
  49         int                             surfaceindex;
  50         // old decals are killed to obey cl_decals_max
  51         unsigned int    decalsequence;
  52 }
  53 tridecal_t;
  54
  55 typedef struct decalsystem_s
  56 {
  57         model_t *model;
  58         double lastupdatetime;
  59         int maxdecals;
  60         int freedecal;
  61         int numdecals;
  62         tridecal_t *decals;
  63         float *vertex3f;
  64         float *texcoord2f;
  65         float *color4f;
  66         int *element3i;
  67         unsigned short *element3s;
  68 }
  69 decalsystem_t;
  70
  71 typedef struct effect_s
  72 {
  73         int active;
  74         vec3_t origin;
  75         double starttime;
  76         float framerate;
  77         model_t *model;
  78         int startframe;
  79         int endframe;
  80         // these are for interpolation
  81         int frame;
  82         double frame1time;
  83         double frame2time;
  84 }
  85 cl_effect_t;
  86
  87 typedef struct beam_s
  88 {
  89         int             entity;
  90         // draw this as lightning polygons, or a model?
  91         int             lightning;
  92         struct model_s  *model;
  93         float   endtime;
  94         vec3_t  start, end;
  95 }
  96 beam_t;
  97
  98 typedef struct rtlight_particle_s
  99 {
 100         float origin[3];
 101         float color[3];
 102 }
 103 rtlight_particle_t;
 104
 105 typedef struct rtlight_s
 106 {
 107         // note that the world to light matrices are inversely scaled (divided) by lightradius
 108
 109         // core properties
 110         /// matrix for transforming light filter coordinates to world coordinates
 111         matrix4x4_t matrix_lighttoworld;
 112         /// matrix for transforming world coordinates to light filter coordinates
 113         matrix4x4_t matrix_worldtolight;
 114         /// typically 1 1 1, can be lower (dim) or higher (overbright)
 115         vec3_t color;
 116         /// size of the light (remove?)
 117         vec_t radius;
 118         /// light filter
 119         char cubemapname[64];
 120         /// light style to monitor for brightness
 121         int style;
 122         /// whether light should render shadows (see castshadows for whether it actually does this frame)
 123         int shadow;
 124         /// intensity of corona to render
 125         vec_t corona;
 126         /// radius scale of corona to render (1.0 means same as light radius)
 127         vec_t coronasizescale;
 128         /// ambient intensity to render
 129         vec_t ambientscale;
 130         /// diffuse intensity to render
 131         vec_t diffusescale;
 132         /// specular intensity to render
 133         vec_t specularscale;
 134         /// LIGHTFLAG_* flags
 135         int flags;
 136
 137         // generated properties
 138         /// used only for casting shadows
 139         vec3_t shadoworigin;
 140         /// culling
 141         vec3_t cullmins;
 142         vec3_t cullmaxs;
 143         /// when r_shadow_culllights_trace is set, this is refreshed by each successful trace.
 144         double trace_timer;
 145
 146         // rendering properties, updated each time a light is rendered
 147         // this is rtlight->color * d_lightstylevalue
 148         vec3_t currentcolor;
 149         /// used by corona updates, due to occlusion query
 150         float corona_visibility;
 151         unsigned int corona_queryindex_visiblepixels;
 152         unsigned int corona_queryindex_allpixels;
 153         /// this is R_GetCubemap(rtlight->cubemapname)
 154         rtexture_t *currentcubemap;
 155         /// set by R_Shadow_PrepareLight to decide whether R_Shadow_DrawLight should draw it
 156         qbool draw;
 157         /// set by R_Shadow_PrepareLight to indicate whether R_Shadow_DrawShadowMaps should do anything
 158         qbool castshadows;
 159         /// these fields are set by R_Shadow_PrepareLight for later drawing
 160         int cached_numlightentities;
 161         int cached_numlightentities_noselfshadow;
 162         int cached_numshadowentities;
 163         int cached_numshadowentities_noselfshadow;
 164         int cached_numsurfaces;
 165         struct entity_render_s **cached_lightentities;
 166         struct entity_render_s **cached_lightentities_noselfshadow;
 167         struct entity_render_s **cached_shadowentities;
 168         struct entity_render_s **cached_shadowentities_noselfshadow;
 169         unsigned char *cached_shadowtrispvs;
 170         unsigned char *cached_lighttrispvs;
 171         int *cached_surfacelist;
 172         // reduced light cullbox from GetLightInfo
 173         vec3_t cached_cullmins;
 174         vec3_t cached_cullmaxs;
 175         // current shadow-caster culling planes based on view
 176         // (any geometry outside these planes can not contribute to the visible
 177         //  shadows in any way, and thus can be culled safely)
 178         int cached_numfrustumplanes;
 179         mplane_t cached_frustumplanes[5]; // see R_Shadow_ComputeShadowCasterCullingPlanes
 180
 181         /// static light info
 182         /// true if this light should be compiled as a static light
 183         int isstatic;
 184         /// true if this is a compiled world light, cleared if the light changes
 185         int compiled;
 186         /// the size that this light should have (assuming no scene LOD kicking in to reduce it)
 187         int shadowmapsidesize;
 188         /// position of this light in the shadowmap atlas
 189         int shadowmapatlasposition[2];
 190         /// 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)
 191         int shadowmapatlassidesize;
 192         /// optimized and culled mesh to render for world entity shadows
 193         shadowmesh_t *static_meshchain_shadow_shadowmap;
 194         /// used for visibility testing (more exact than bbox)
 195         int static_numleafs;
 196         int static_numleafpvsbytes;
 197         int *static_leaflist;
 198         unsigned char *static_leafpvs;
 199         /// surfaces seen by light
 200         int static_numsurfaces;
 201         int *static_surfacelist;
 202         /// flag bits indicating which triangles of the world model should cast
 203         /// shadows, and which ones should be lit
 204         ///
 205         /// this avoids redundantly scanning the triangles in each surface twice
 206         /// for whether they should cast shadows, once in culling and once in the
 207         /// actual shadowmarklist production.
 208         int static_numshadowtrispvsbytes;
 209         unsigned char *static_shadowtrispvs;
 210         /// this allows the lighting batch code to skip backfaces andother culled
 211         /// triangles not relevant for lighting
 212         /// (important on big surfaces such as terrain)
 213         int static_numlighttrispvsbytes;
 214         unsigned char *static_lighttrispvs;
 215         /// masks of all shadowmap sides that have any potential static receivers or casters
 216         int static_shadowmap_receivers;
 217         int static_shadowmap_casters;
 218         /// particle-tracing cache for global illumination
 219         int particlecache_numparticles;
 220         int particlecache_maxparticles;
 221         int particlecache_updateparticle;
 222         rtlight_particle_t *particlecache_particles;
 223
 224         /// bouncegrid light info
 225         float bouncegrid_photoncolor[3];
 226         float bouncegrid_photons;
 227         int bouncegrid_hits;
 228         int bouncegrid_traces;
 229         float bouncegrid_effectiveradius;
 230 }
 231 rtlight_t;
 232
 233 typedef struct dlight_s
 234 {
 235         // destroy light after this time
 236         // (dlight only)
 237         vec_t die;
 238         // the entity that owns this light (can be NULL)
 239         // (dlight only)
 240         struct entity_render_s *ent;
 241         // location
 242         // (worldlight: saved to .rtlights file)
 243         vec3_t origin;
 244         // worldlight orientation
 245         // (worldlight only)
 246         // (worldlight: saved to .rtlights file)
 247         vec3_t angles;
 248         // dlight orientation/scaling/location
 249         // (dlight only)
 250         matrix4x4_t matrix;
 251         // color of light
 252         // (worldlight: saved to .rtlights file)
 253         vec3_t color;
 254         // cubemap name to use on this light
 255         // (worldlight: saved to .rtlights file)
 256         char cubemapname[64];
 257         // make light flash while selected
 258         // (worldlight only)
 259         int selected;
 260         // brightness (not really radius anymore)
 261         // (worldlight: saved to .rtlights file)
 262         vec_t radius;
 263         // drop intensity this much each second
 264         // (dlight only)
 265         vec_t decay;
 266         // intensity value which is dropped over time
 267         // (dlight only)
 268         vec_t intensity;
 269         // initial values for intensity to modify
 270         // (dlight only)
 271         vec_t initialradius;
 272         vec3_t initialcolor;
 273         // light style which controls intensity of this light
 274         // (worldlight: saved to .rtlights file)
 275         int style;
 276         // cast shadows
 277         // (worldlight: saved to .rtlights file)
 278         int shadow;
 279         // corona intensity
 280         // (worldlight: saved to .rtlights file)
 281         vec_t corona;
 282         // radius scale of corona to render (1.0 means same as light radius)
 283         // (worldlight: saved to .rtlights file)
 284         vec_t coronasizescale;
 285         // ambient intensity to render
 286         // (worldlight: saved to .rtlights file)
 287         vec_t ambientscale;
 288         // diffuse intensity to render
 289         // (worldlight: saved to .rtlights file)
 290         vec_t diffusescale;
 291         // specular intensity to render
 292         // (worldlight: saved to .rtlights file)
 293         vec_t specularscale;
 294         // LIGHTFLAG_* flags
 295         // (worldlight: saved to .rtlights file)
 296         int flags;
 297         // linked list of world lights
 298         // (worldlight only)
 299         struct dlight_s *next;
 300         // embedded rtlight struct for renderer
 301         // (worldlight only)
 302         rtlight_t rtlight;
 303 }
 304 dlight_t;
 305
 306 // this is derived from processing of the framegroupblend array
 307 // note: technically each framegroupblend can produce two of these, but that
 308 // never happens in practice because no one blends between more than 2
 309 // framegroups at once
 310 #define MAX_FRAMEBLENDS (MAX_FRAMEGROUPBLENDS * 2)
 311 typedef struct frameblend_s
 312 {
 313         int subframe;
 314         float lerp;
 315 }
 316 frameblend_t;
 317
 318 // LadyHavoc: this struct is intended for the renderer but some fields are
 319 // used by the client.
 320 //
 321 // The renderer should not rely on any changes to this struct to be persistent
 322 // across multiple frames because temp entities are wiped every frame, but it
 323 // is acceptable to cache things in this struct that are not critical.
 324 //
 325 // For example the r_cullentities_trace code does such caching.
 326 typedef struct entity_render_s
 327 {
 328         // location
 329         //vec3_t origin;
 330         // orientation
 331         //vec3_t angles;
 332         // transform matrix for model to world
 333         matrix4x4_t matrix;
 334         // transform matrix for world to model
 335         matrix4x4_t inversematrix;
 336         // opacity (alpha) of the model
 337         float alpha;
 338         // size the model is shown
 339         float scale;
 340         // transparent sorting offset
 341         float transparent_offset;
 342
 343         // NULL = no model
 344         model_t *model;
 345         // number of the entity represents, or 0 for non-network entities
 346         int entitynumber;
 347         // literal colormap colors for renderer, if both are 0 0 0 it is not colormapped
 348         vec3_t colormap_pantscolor;
 349         vec3_t colormap_shirtcolor;
 350         // light, particles, etc
 351         int effects;
 352         // qw CTF flags and other internal-use-only effect bits
 353         int internaleffects;
 354         // for Alias models
 355         int skinnum;
 356         // render flags
 357         int flags;
 358
 359         // colormod tinting of models
 360         float colormod[3];
 361         float glowmod[3];
 362
 363         // interpolated animation - active framegroups and blend factors
 364         framegroupblend_t framegroupblend[MAX_FRAMEGROUPBLENDS];
 365
 366         // time of last model change (for shader animations)
 367         double shadertime;
 368
 369         // calculated by the renderer (but not persistent)
 370
 371         // calculated during R_AddModelEntities
 372         vec3_t mins, maxs;
 373         // subframe numbers (-1 if not used) and their blending scalers (0-1), if interpolation is not desired, use subframeblend[0].subframe
 374         frameblend_t frameblend[MAX_FRAMEBLENDS];
 375         // skeletal animation data (if skeleton.relativetransforms is not NULL, it overrides frameblend)
 376         skeleton_t *skeleton;
 377
 378         // animation cache (pointers allocated using R_FrameData_Alloc)
 379         // ONLY valid during R_RenderView!  may be NULL (not cached)
 380         float          *animcache_vertex3f;
 381         r_meshbuffer_t *animcache_vertex3f_vertexbuffer;
 382         int             animcache_vertex3f_bufferoffset;
 383         float          *animcache_normal3f;
 384         r_meshbuffer_t *animcache_normal3f_vertexbuffer;
 385         int             animcache_normal3f_bufferoffset;
 386         float          *animcache_svector3f;
 387         r_meshbuffer_t *animcache_svector3f_vertexbuffer;
 388         int             animcache_svector3f_bufferoffset;
 389         float          *animcache_tvector3f;
 390         r_meshbuffer_t *animcache_tvector3f_vertexbuffer;
 391         int             animcache_tvector3f_bufferoffset;
 392         // gpu-skinning shader needs transforms in a certain format, we have to
 393         // upload this to a uniform buffer for the shader to use, and also keep a
 394         // backup copy in system memory for the dynamic batch fallback code
 395         // if this is not NULL, the other animcache variables are NULL
 396         float *animcache_skeletaltransform3x4;
 397         r_meshbuffer_t *animcache_skeletaltransform3x4buffer;
 398         int animcache_skeletaltransform3x4offset;
 399         int animcache_skeletaltransform3x4size;
 400
 401         // CL_UpdateEntityShading reads these fields
 402         // used only if RENDER_CUSTOMIZEDMODELLIGHT is set
 403         vec3_t custommodellight_ambient;
 404         vec3_t custommodellight_diffuse;
 405         vec3_t custommodellight_lightdir;
 406         // CSQC entities get their shading from the root of their attachment chain
 407         float custommodellight_origin[3];
 408
 409         // derived lighting parameters (CL_UpdateEntityShading)
 410
 411         // used by MATERIALFLAG_FULLBRIGHT which is MATERIALFLAG_MODELLIGHT with
 412         // this as ambient color, along with MATERIALFLAG_NORTLIGHT
 413         float render_fullbright[3];
 414         // color tint for the base pass glow textures if any
 415         float render_glowmod[3];
 416         // MATERIALFLAG_MODELLIGHT uses these parameters
 417         float render_modellight_ambient[3];
 418         float render_modellight_diffuse[3];
 419         float render_modellight_lightdir_world[3];
 420         float render_modellight_lightdir_local[3];
 421         float render_modellight_specular[3];
 422         // lightmap rendering (not MATERIALFLAG_MODELLIGHT)
 423         float render_lightmap_ambient[3];
 424         float render_lightmap_diffuse[3];
 425         float render_lightmap_specular[3];
 426         // rtlights use these colors for the materials on this entity
 427         float render_rtlight_diffuse[3];
 428         float render_rtlight_specular[3];
 429         // ignore lightmap and use fixed lighting settings on this entity (e.g. FULLBRIGHT)
 430         qbool render_modellight_forced;
 431         // do not process per pixel lights on this entity at all (like MATERIALFLAG_NORTLIGHT)
 432         qbool render_rtlight_disabled;
 433         // use the 3D lightmap from q3bsp on this entity
 434         qbool render_lightgrid;
 435
 436         // storage of decals on this entity
 437         // (note: if allowdecals is set, be sure to call R_DecalSystem_Reset on removal!)
 438         int allowdecals;
 439         decalsystem_t decalsystem;
 440
 441         // FIELDS UPDATED BY RENDERER:
 442         // last time visible during trace culling
 443         double last_trace_visibility;
 444
 445         // user wavefunc parameters (from csqc)
 446         vec_t userwavefunc_param[Q3WAVEFUNC_USER_COUNT];
 447 }
 448 entity_render_t;
 449
 450 typedef struct entity_persistent_s
 451 {
 452         vec3_t trail_origin; // previous position for particle trail spawning
 453         vec3_t oldorigin; // lerp
 454         vec3_t oldangles; // lerp
 455         vec3_t neworigin; // lerp
 456         vec3_t newangles; // lerp
 457         vec_t lerpstarttime; // lerp
 458         vec_t lerpdeltatime; // lerp
 459         float muzzleflash; // muzzleflash intensity, fades over time
 460         float trail_time; // residual error accumulation for particle trail spawning (to keep spacing across frames)
 461         qbool trail_allowed; // set to false by teleports, true by update code, prevents bad lerps
 462 }
 463 entity_persistent_t;
 464
 465 typedef struct entity_s
 466 {
 467         // baseline state (default values)
 468         entity_state_t state_baseline;
 469         // previous state (interpolating from this)
 470         entity_state_t state_previous;
 471         // current state (interpolating to this)
 472         entity_state_t state_current;
 473
 474         // used for regenerating parts of render
 475         entity_persistent_t persistent;
 476
 477         // the only data the renderer should know about
 478         entity_render_t render;
 479 }
 480 entity_t;
 481
 482 typedef struct lightstyle_s
 483 {
 484         int             length;
 485         char    map[MAX_STYLESTRING];
 486 } lightstyle_t;
 487
 488 typedef struct scoreboard_s
 489 {
 490         char    name[MAX_SCOREBOARDNAME];
 491         int             frags;
 492         int             colors; // two 4 bit fields
 493         // QW fields:
 494         int             qw_userid;
 495         char    qw_userinfo[MAX_USERINFO_STRING];
 496         float   qw_entertime;
 497         int             qw_ping;
 498         int             qw_packetloss;
 499         int             qw_movementloss;
 500         int             qw_spectator;
 501         char    qw_team[8];
 502         char    qw_skin[MAX_QPATH];
 503 } scoreboard_t;
 504
 505 typedef struct cshift_s
 506 {
 507         float   destcolor[3];
 508         float   percent;                // 0-255
 509         float   alphafade;      // (any speed)
 510 } cshift_t;
 511
 512 #define CSHIFT_CONTENTS 0
 513 #define CSHIFT_DAMAGE   1
 514 #define CSHIFT_BONUS    2
 515 #define CSHIFT_POWERUP  3
 516 #define CSHIFT_VCSHIFT  4
 517 #define NUM_CSHIFTS             5
 518
 519 #define NAME_LENGTH     64
 520
 521
 522 //
 523 // client_state_t should hold all pieces of the client state
 524 //
 525
 526 #define SIGNONS         4                       // signon messages to receive before connected
 527
 528 typedef enum cactive_e
 529 {
 530         ca_uninitialized,       // during early startup
 531         ca_dedicated,           // a dedicated server with no ability to start a client
 532         ca_disconnected,        // full screen console with no connection
 533         ca_connected            // valid netcon, talking to a server
 534 }
 535 cactive_t;
 536
 537 typedef enum qw_downloadtype_e
 538 {
 539         dl_none,
 540         dl_single,
 541         dl_skin,
 542         dl_model,
 543         dl_sound
 544 }
 545 qw_downloadtype_t;
 546
 547 #define CL_MAX_DOWNLOADACKS 4
 548
 549 typedef struct cl_downloadack_s
 550 {
 551         int start, size;
 552 }
 553 cl_downloadack_t;
 554
 555 typedef struct cl_soundstats_s
 556 {
 557         int mixedsounds;
 558         int totalsounds;
 559         int latency_milliseconds;
 560 }
 561 cl_soundstats_t;
 562
 563 //
 564 // the client_static_t structure is persistent through an arbitrary number
 565 // of server connections
 566 //
 567 typedef struct client_static_s
 568 {
 569         cactive_t state;
 570
 571         // all client memory allocations go in these pools
 572         mempool_t *levelmempool;
 573         mempool_t *permanentmempool;
 574
 575 // demo loop control
 576         // -1 = don't play demos
 577         int demonum;
 578         // list of demos in loop
 579         char demos[MAX_DEMOS][MAX_DEMONAME];
 580         // the actively playing demo (set by CL_PlayDemo)
 581         char demoname[MAX_QPATH];
 582
 583 // demo recording info must be here, because record is started before
 584 // entering a map (and clearing client_state_t)
 585         qbool demorecording;
 586         fs_offset_t demo_lastcsprogssize;
 587         int demo_lastcsprogscrc;
 588         qbool demoplayback;
 589         qbool demostarting; // set if currently starting a demo, to stop -demo from quitting when switching to another demo
 590         qbool timedemo;
 591         // -1 = use normal cd track
 592         int forcetrack;
 593         qfile_t *demofile;
 594         // realtime at second frame of timedemo (LadyHavoc: changed to double)
 595         double td_starttime;
 596         int td_frames; // total frames parsed
 597         double td_onesecondnexttime;
 598         double td_onesecondframes;
 599         double td_onesecondrealtime;
 600         double td_onesecondminfps;
 601         double td_onesecondmaxfps;
 602         double td_onesecondavgfps;
 603         int td_onesecondavgcount;
 604         // LadyHavoc: pausedemo
 605         qbool demopaused;
 606
 607         // sound mixer statistics for showsound display
 608         cl_soundstats_t soundstats;
 609
 610         qbool connect_trying;
 611         int connect_remainingtries;
 612         double connect_nextsendtime;
 613         lhnetsocket_t *connect_mysocket;
 614         lhnetaddress_t connect_address;
 615         lhnetaddress_t rcon_address;
 616         // protocol version of the server we're connected to
 617         // (kept outside client_state_t because it's used between levels)
 618         protocolversion_t protocol;
 619
 620 #define MAX_RCONS 16
 621         int rcon_trying;
 622         lhnetaddress_t rcon_addresses[MAX_RCONS];
 623         char rcon_commands[MAX_RCONS][MAX_INPUTLINE];
 624         double rcon_timeout[MAX_RCONS];
 625         int rcon_ringpos;
 626
 627 // connection information
 628         // 0 to SIGNONS
 629         int signon;
 630         // network connection
 631         netconn_t *netcon;
 632
 633         // download information
 634         // (note: qw_download variables are also used)
 635         cl_downloadack_t dp_downloadack[CL_MAX_DOWNLOADACKS];
 636
 637         // input sequence numbers are not reset on level change, only connect
 638         unsigned int servermovesequence;
 639
 640         // quakeworld stuff below
 641
 642         // value of "qport" cvar at time of connection
 643         int qw_qport;
 644         // copied from cls.netcon->qw. variables every time they change, or set by demos (which have no cls.netcon)
 645         unsigned int qw_incoming_sequence;
 646         unsigned int qw_outgoing_sequence;
 647
 648         // current file download buffer (only saved when file is completed)
 649         char qw_downloadname[MAX_QPATH];
 650         unsigned char *qw_downloadmemory;
 651         int qw_downloadmemorycursize;
 652         int qw_downloadmemorymaxsize;
 653         int qw_downloadnumber;
 654         int qw_downloadpercent;
 655         qw_downloadtype_t qw_downloadtype;
 656         // transfer rate display
 657         double qw_downloadspeedtime;
 658         int qw_downloadspeedcount;
 659         int qw_downloadspeedrate;
 660         qbool qw_download_deflate;
 661
 662         // current file upload buffer (for uploading screenshots to server)
 663         unsigned char *qw_uploaddata;
 664         int qw_uploadsize;
 665         int qw_uploadpos;
 666
 667         // user infostring
 668         // this normally contains the following keys in quakeworld:
 669         // password spectator name team skin topcolor bottomcolor rate noaim msg *ver *ip
 670         char userinfo[MAX_USERINFO_STRING];
 671
 672         // extra user info for the "connect" command
 673         char connect_userinfo[MAX_USERINFO_STRING];
 674
 675 #ifdef CONFIG_VIDEO_CAPTURE
 676         // video capture stuff
 677         capturevideostate_t capturevideo;
 678 #endif
 679
 680         // crypto channel
 681         crypto_t crypto;
 682
 683         // ProQuake compatibility stuff
 684         int proquake_servermod; // 0 = not proquake, 1 = proquake
 685         int proquake_serverversion; // actual proquake server version * 10 (3.40 = 34, etc)
 686         int proquake_serverflags; // 0 (PQF_CHEATFREE not supported)
 687
 688         // don't write-then-read csprogs.dat (useful for demo playback)
 689         unsigned char *caughtcsprogsdata;
 690         fs_offset_t caughtcsprogsdatasize;
 691
 692         int r_speeds_graph_length;
 693         int r_speeds_graph_current;
 694         int *r_speeds_graph_data;
 695
 696         // graph scales
 697         int r_speeds_graph_datamin[r_stat_count];
 698         int r_speeds_graph_datamax[r_stat_count];
 699 }
 700 client_static_t;
 701
 702 extern client_static_t  cls;
 703
 704 //[515]: csqc
 705 typedef struct
 706 {
 707         qbool drawworld;
 708         qbool drawenginesbar;
 709         qbool drawcrosshair;
 710 }csqc_vidvars_t;
 711
 712 typedef enum cl_parsingtextmode_e
 713 {
 714         CL_PARSETEXTMODE_NONE,
 715         CL_PARSETEXTMODE_PING,
 716         CL_PARSETEXTMODE_STATUS,
 717         CL_PARSETEXTMODE_STATUS_PLAYERID,
 718         CL_PARSETEXTMODE_STATUS_PLAYERIP
 719 }
 720 cl_parsingtextmode_t;
 721
 722 typedef struct cl_locnode_s
 723 {
 724         struct cl_locnode_s *next;
 725         char *name;
 726         vec3_t mins, maxs;
 727 }
 728 cl_locnode_t;
 729
 730 typedef struct showlmp_s
 731 {
 732         qbool   isactive;
 733         float           x;
 734         float           y;
 735         char            label[32];
 736         char            pic[128];
 737 }
 738 showlmp_t;
 739
 740 //
 741 // the client_state_t structure is wiped completely at every
 742 // server signon
 743 //
 744 typedef struct client_state_s
 745 {
 746         // true if playing in a local game and no one else is connected
 747         int islocalgame;
 748
 749         // send a clc_nop periodically until connected
 750         float sendnoptime;
 751
 752         // current input being accumulated by mouse/joystick/etc input
 753         usercmd_t cmd;
 754         // latest moves sent to the server that have not been confirmed yet
 755         usercmd_t movecmd[CL_MAX_USERCMDS];
 756
 757 // information for local display
 758         // health, etc
 759         int stats[MAX_CL_STATS];
 760         float *statsf; // points to stats[] array
 761         // last known inventory bit flags, for blinking
 762         int olditems;
 763         // cl.time of acquiring item, for blinking
 764         float item_gettime[32];
 765         // last known STAT_ACTIVEWEAPON
 766         int activeweapon;
 767         // cl.time of changing STAT_ACTIVEWEAPON
 768         float weapontime;
 769         // use pain anim frame if cl.time < this
 770         float faceanimtime;
 771         // for stair smoothing
 772         float stairsmoothz;
 773         double stairsmoothtime;
 774
 775         // color shifts for damage, powerups
 776         cshift_t cshifts[NUM_CSHIFTS];
 777         // and content types
 778         cshift_t prev_cshifts[NUM_CSHIFTS];
 779
 780 // the client maintains its own idea of view angles, which are
 781 // sent to the server each frame.  The server sets punchangle when
 782 // the view is temporarily offset, and an angle reset commands at the start
 783 // of each level and after teleporting.
 784
 785         // mviewangles is read from demo
 786         // viewangles is either client controlled or lerped from mviewangles
 787         vec3_t mviewangles[2], viewangles;
 788         // update by server, used by qc to do weapon recoil
 789         vec3_t mpunchangle[2], punchangle;
 790         // update by server, can be used by mods to kick view around
 791         vec3_t mpunchvector[2], punchvector;
 792         // update by server, used for lean+bob (0 is newest)
 793         vec3_t mvelocity[2], velocity;
 794         // update by server, can be used by mods for zooming
 795         vec_t mviewzoom[2], viewzoom;
 796         // if true interpolation the mviewangles and other interpolation of the
 797         // player is disabled until the next network packet
 798         // this is used primarily by teleporters, and when spectating players
 799         // special checking of the old fixangle[1] is used to differentiate
 800         // between teleporting and spectating
 801         qbool fixangle[2];
 802
 803         // client movement simulation
 804         // these fields are only updated by CL_ClientMovement (called by CL_SendMove after parsing each network packet)
 805         // set by CL_ClientMovement_Replay functions
 806         qbool movement_predicted;
 807         // if true the CL_ClientMovement_Replay function will update origin, etc
 808         qbool movement_replay;
 809         // simulated data (this is valid even if cl.movement is false)
 810         vec3_t movement_origin;
 811         vec3_t movement_velocity;
 812         // whether the replay should allow a jump at the first sequence
 813         qbool movement_replay_canjump;
 814
 815         // previous gun angles (for leaning effects)
 816         vec3_t gunangles_prev;
 817         vec3_t gunangles_highpass;
 818         vec3_t gunangles_adjustment_lowpass;
 819         vec3_t gunangles_adjustment_highpass;
 820         // previous gun angles (for leaning effects)
 821         vec3_t gunorg_prev;
 822         vec3_t gunorg_highpass;
 823         vec3_t gunorg_adjustment_lowpass;
 824         vec3_t gunorg_adjustment_highpass;
 825
 826 // pitch drifting vars
 827         float idealpitch;
 828         float pitchvel;
 829         qbool nodrift;
 830         float driftmove;
 831         double laststop;
 832
 833 //[515]: added for csqc purposes
 834         float sensitivityscale;
 835         csqc_vidvars_t csqc_vidvars;    //[515]: these parms must be set to true by default
 836         qbool csqc_wantsmousemove;
 837         struct model_s *csqc_model_precache[MAX_MODELS];
 838
 839         // local amount for smoothing stepups
 840         //float crouch;
 841
 842         // sent by server
 843         qbool paused;
 844         qbool onground;
 845         qbool inwater;
 846
 847         // used by bob
 848         qbool oldonground;
 849         double lastongroundtime;
 850         double hitgroundtime;
 851         float bob2_smooth;
 852         float bobfall_speed;
 853         float bobfall_swing;
 854         double calcrefdef_prevtime;
 855
 856         // don't change view angle, full screen, etc
 857         int intermission;
 858         // latched at intermission start
 859         double completed_time;
 860
 861         // the timestamp of the last two messages
 862         double mtime[2];
 863
 864         // clients view of time, time should be between mtime[0] and mtime[1] to
 865         // generate a lerp point for other data, oldtime is the previous frame's
 866         // value of time, frametime is the difference between time and oldtime
 867         // note: cl.time may be beyond cl.mtime[0] if packet loss is occuring, it
 868         // is only forcefully limited when a packet is received
 869         double time, oldtime;
 870         // how long it has been since the previous client frame in real time
 871         // (not game time, for that use cl.time - cl.oldtime)
 872         double realframetime;
 873
 874         // used by cl_nettimesyncboundmode 7
 875 #define NUM_TS_ERRORS 32 // max 256
 876         unsigned char ts_error_num;
 877         float ts_error_stor[NUM_TS_ERRORS];
 878
 879         // fade var for fading while dead
 880         float deathfade;
 881
 882         // motionblur alpha level variable
 883         float motionbluralpha;
 884
 885         // copy of realtime from last recieved message, for net trouble icon
 886         float last_received_message;
 887
 888 // information that is static for the entire time connected to a server
 889         struct model_s *model_precache[MAX_MODELS];
 890         struct sfx_s *sound_precache[MAX_SOUNDS];
 891
 892         // FIXME: this is a lot of memory to be keeping around, this really should be dynamically allocated and freed somehow
 893         char model_name[MAX_MODELS][MAX_QPATH];
 894         char sound_name[MAX_SOUNDS][MAX_QPATH];
 895
 896         // for display on solo scoreboard
 897         char worldmessage[40]; // map title (not related to filename)
 898         // variants of map name
 899         char worldbasename[MAX_QPATH]; // %s
 900         char worldname[MAX_QPATH]; // maps/%s.bsp
 901         char worldnamenoextension[MAX_QPATH]; // maps/%s
 902         // cl_entitites[cl.viewentity] = player
 903         int viewentity;
 904         // the real player entity (normally same as viewentity,
 905         // different than viewentity if mod uses chasecam or other tricks)
 906         int realplayerentity;
 907         // this is updated to match cl.viewentity whenever it is in the clients
 908         // range, basically this is used in preference to cl.realplayerentity for
 909         // most purposes because when spectating another player it should show
 910         // their information rather than yours
 911         int playerentity;
 912         // max players that can be in this game
 913         int maxclients;
 914         // type of game (deathmatch, coop, singleplayer)
 915         int gametype;
 916
 917         // models and sounds used by engine code (particularly cl_parse.c)
 918         model_t *model_bolt;
 919         model_t *model_bolt2;
 920         model_t *model_bolt3;
 921         model_t *model_beam;
 922         sfx_t *sfx_wizhit;
 923         sfx_t *sfx_knighthit;
 924         sfx_t *sfx_tink1;
 925         sfx_t *sfx_ric1;
 926         sfx_t *sfx_ric2;
 927         sfx_t *sfx_ric3;
 928         sfx_t *sfx_r_exp3;
 929         // indicates that the file "sound/misc/talk2.wav" was found (for use by team chat messages)
 930         qbool foundteamchatsound;
 931
 932 // refresh related state
 933
 934         // cl_entitites[0].model
 935         struct model_s *worldmodel;
 936
 937         // the gun model
 938         entity_t viewent;
 939
 940         // cd audio
 941         int cdtrack, looptrack;
 942
 943 // frag scoreboard
 944
 945         // [cl.maxclients]
 946         scoreboard_t *scores;
 947
 948         // keep track of svc_print parsing state (analyzes ping reports and status reports)
 949         cl_parsingtextmode_t parsingtextmode;
 950         int parsingtextplayerindex;
 951         // set by scoreboard code when sending ping command, this causes the next ping results to be hidden
 952         // (which could eat the wrong ping report if the player issues one
 953         //  manually, but they would still see a ping report, just a later one
 954         //  caused by the scoreboard code rather than the one they intentionally
 955         //  issued)
 956         int parsingtextexpectingpingforscores;
 957
 958         // entity database stuff
 959         // latest received entity frame numbers
 960 #define LATESTFRAMENUMS 32
 961         int latestframenumsposition;
 962         int latestframenums[LATESTFRAMENUMS];
 963         unsigned int latestsendnums[LATESTFRAMENUMS];
 964         entityframe_database_t *entitydatabase;
 965         entityframe4_database_t *entitydatabase4;
 966         entityframeqw_database_t *entitydatabaseqw;
 967
 968         // keep track of quake entities because they need to be killed if they get stale
 969         int lastquakeentity;
 970         unsigned char isquakeentity[MAX_EDICTS];
 971
 972         // bounding boxes for clientside movement
 973         vec3_t playerstandmins;
 974         vec3_t playerstandmaxs;
 975         vec3_t playercrouchmins;
 976         vec3_t playercrouchmaxs;
 977
 978         // old decals are killed based on this
 979         unsigned int decalsequence;
 980
 981         int max_entities;
 982         int max_csqcrenderentities;
 983         int max_static_entities;
 984         int max_effects;
 985         int max_beams;
 986         int max_dlights;
 987         int max_lightstyle;
 988         int max_brushmodel_entities;
 989         int max_particles;
 990         int max_showlmps;
 991
 992         entity_t *entities;
 993         entity_render_t *csqcrenderentities;
 994         unsigned char *entities_active;
 995         entity_t *static_entities;
 996         cl_effect_t *effects;
 997         beam_t *beams;
 998         dlight_t *dlights;
 999         lightstyle_t *lightstyle;
1000         int *brushmodel_entities;
1001         particle_t *particles;
1002         showlmp_t *showlmps;
1003
1004         int num_entities;
1005         int num_static_entities;
1006         int num_brushmodel_entities;
1007         int num_effects;
1008         int num_beams;
1009         int num_dlights;
1010         int num_particles;
1011         int num_decals;
1012         int num_showlmps;
1013
1014         double particles_updatetime;
1015         double decals_updatetime;
1016         int free_particle;
1017         int free_decal;
1018
1019         // cl_serverextension_download feature
1020         int loadmodel_current;
1021         int downloadmodel_current;
1022         int loadmodel_total;
1023         int loadsound_current;
1024         int downloadsound_current;
1025         int loadsound_total;
1026         qbool downloadcsqc;
1027         qbool loadcsqc;
1028         qbool loadbegun;
1029         qbool loadfinished;
1030
1031         // quakeworld stuff
1032
1033         // local copy of the server infostring
1034         char qw_serverinfo[MAX_SERVERINFO_STRING];
1035
1036         // time of last qw "pings" command sent to server while showing scores
1037         double last_ping_request;
1038
1039         // used during connect
1040         int qw_servercount;
1041
1042         // updated from serverinfo
1043         int qw_teamplay;
1044
1045         // unused: indicates whether the player is spectating
1046         // use cl.scores[cl.playerentity-1].qw_spectator instead
1047         //qbool qw_spectator;
1048
1049         // time accumulated since an input packet was sent
1050         float timesincepacket;
1051
1052         // movement parameters for client prediction
1053         unsigned int moveflags;
1054         float movevars_wallfriction;
1055         float movevars_waterfriction;
1056         float movevars_friction;
1057         float movevars_timescale;
1058         float movevars_gravity;
1059         float movevars_stopspeed;
1060         float movevars_maxspeed;
1061         float movevars_spectatormaxspeed;
1062         float movevars_accelerate;
1063         float movevars_airaccelerate;
1064         float movevars_wateraccelerate;
1065         float movevars_entgravity;
1066         float movevars_jumpvelocity;
1067         float movevars_edgefriction;
1068         float movevars_maxairspeed;
1069         float movevars_stepheight;
1070         float movevars_airaccel_qw;
1071         float movevars_airaccel_qw_stretchfactor;
1072         float movevars_airaccel_sideways_friction;
1073         float movevars_airstopaccelerate;
1074         float movevars_airstrafeaccelerate;
1075         float movevars_maxairstrafespeed;
1076         float movevars_airstrafeaccel_qw;
1077         float movevars_aircontrol;
1078         float movevars_aircontrol_power;
1079         float movevars_aircontrol_penalty;
1080         float movevars_warsowbunny_airforwardaccel;
1081         float movevars_warsowbunny_accel;
1082         float movevars_warsowbunny_topspeed;
1083         float movevars_warsowbunny_turnaccel;
1084         float movevars_warsowbunny_backtosideratio;
1085         float movevars_ticrate;
1086         float movevars_airspeedlimit_nonqw;
1087
1088         // models used by qw protocol
1089         int qw_modelindex_spike;
1090         int qw_modelindex_player;
1091         int qw_modelindex_flag;
1092         int qw_modelindex_s_explod;
1093
1094         vec3_t qw_intermission_origin;
1095         vec3_t qw_intermission_angles;
1096
1097         // 255 is the most nails the QW protocol could send
1098         int qw_num_nails;
1099         vec_t qw_nails[255][6];
1100
1101         float qw_weaponkick;
1102
1103         unsigned int qw_validsequence;
1104
1105         unsigned int qw_deltasequence[QW_UPDATE_BACKUP];
1106
1107         // csqc stuff:
1108         // server entity number corresponding to a clientside entity
1109         unsigned short csqc_server2csqcentitynumber[MAX_EDICTS];
1110         qbool csqc_loaded;
1111         vec3_t csqc_vieworigin;
1112         vec3_t csqc_viewangles;
1113         vec3_t csqc_vieworiginfromengine;
1114         vec3_t csqc_viewanglesfromengine;
1115         matrix4x4_t csqc_viewmodelmatrixfromengine;
1116         qbool csqc_usecsqclistener;
1117         matrix4x4_t csqc_listenermatrix;
1118         char csqc_printtextbuf[MAX_INPUTLINE];
1119
1120         // collision culling data
1121         world_t world;
1122
1123         // loc file stuff (points and boxes describing locations in the level)
1124         cl_locnode_t *locnodes;
1125         // this is updated to cl.movement_origin whenever health is < 1
1126         // used by %d print in say/say_team messages if cl_locs_enable is on
1127         vec3_t lastdeathorigin;
1128
1129         // processing buffer used by R_BuildLightMap, reallocated as needed,
1130         // freed on each level change
1131         size_t buildlightmapmemorysize;
1132         unsigned char *buildlightmapmemory;
1133
1134         // used by EntityState5_ReadUpdate
1135         skeleton_t *engineskeletonobjects;
1136 }
1137 client_state_t;
1138
1139 //
1140 // cvars
1141 //
1142 extern cvar_t cl_name;
1143 extern cvar_t cl_color;
1144 extern cvar_t cl_rate;
1145 extern cvar_t cl_rate_burstsize;
1146 extern cvar_t cl_pmodel;
1147 extern cvar_t cl_playermodel;
1148 extern cvar_t cl_playerskin;
1149
1150 extern cvar_t rcon_password;
1151 extern cvar_t rcon_address;
1152
1153 extern cvar_t cl_upspeed;
1154 extern cvar_t cl_forwardspeed;
1155 extern cvar_t cl_backspeed;
1156 extern cvar_t cl_sidespeed;
1157
1158 extern cvar_t cl_movespeedkey;
1159
1160 extern cvar_t cl_yawspeed;
1161 extern cvar_t cl_pitchspeed;
1162
1163 extern cvar_t cl_anglespeedkey;
1164
1165 extern cvar_t cl_autofire;
1166
1167 extern cvar_t cl_shownet;
1168 extern cvar_t cl_nolerp;
1169 extern cvar_t cl_nettimesyncfactor;
1170 extern cvar_t cl_nettimesyncboundmode;
1171 extern cvar_t cl_nettimesyncboundtolerance;
1172
1173 extern cvar_t cl_pitchdriftspeed;
1174 extern cvar_t lookspring;
1175 extern cvar_t lookstrafe;
1176 extern cvar_t sensitivity;
1177
1178 extern cvar_t freelook;
1179
1180 extern cvar_t m_pitch;
1181 extern cvar_t m_yaw;
1182 extern cvar_t m_forward;
1183 extern cvar_t m_side;
1184
1185 extern cvar_t cl_autodemo;
1186 extern cvar_t cl_autodemo_nameformat;
1187 extern cvar_t cl_autodemo_delete;
1188
1189 extern cvar_t r_draweffects;
1190
1191 extern cvar_t cl_explosions_alpha_start;
1192 extern cvar_t cl_explosions_alpha_end;
1193 extern cvar_t cl_explosions_size_start;
1194 extern cvar_t cl_explosions_size_end;
1195 extern cvar_t cl_explosions_lifetime;
1196 extern cvar_t cl_stainmaps;
1197 extern cvar_t cl_stainmaps_clearonload;
1198
1199 extern cvar_t cl_prydoncursor;
1200 extern cvar_t cl_prydoncursor_notrace;
1201
1202 extern cvar_t cl_locs_enable;
1203
1204 extern client_state_t cl;
1205
1206 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);
1207
1208 cl_locnode_t *CL_Locs_FindNearest(const vec3_t point);
1209 void CL_Locs_FindLocationName(char *buffer, size_t buffersize, vec3_t point);
1210
1211 //=============================================================================
1212
1213 //
1214 // cl_main
1215 //
1216
1217 double CL_Frame(double time);
1218
1219 void CL_Shutdown (void);
1220 void CL_Init (void);
1221
1222 void CL_StartVideo(void);
1223
1224 void CL_EstablishConnection(const char *host, int firstarg);
1225
1226 void CL_Disconnect (qbool kicked, const char *reason, ... );
1227 void CL_Disconnect_f(cmd_state_t *cmd);
1228
1229 void CL_UpdateRenderEntity(entity_render_t *ent);
1230 void CL_SetEntityColormapColors(entity_render_t *ent, int colormap);
1231 void CL_UpdateViewEntities(void);
1232
1233 //
1234 // cl_input
1235 //
1236 typedef struct kbutton_s
1237 {
1238         int             down[2];                // key nums holding it down
1239         int             state;                  // low bit is down state
1240 }
1241 kbutton_t;
1242
1243 extern  kbutton_t       in_mlook, in_klook;
1244 extern  kbutton_t       in_strafe;
1245 extern  kbutton_t       in_speed;
1246
1247 void CL_InitInput (void);
1248 void CL_SendMove (void);
1249
1250 void CL_ValidateState(entity_state_t *s);
1251 void CL_MoveLerpEntityStates(entity_t *ent);
1252 void CL_LerpUpdate(entity_t *e);
1253 void CL_ParseTEnt (void);
1254 void CL_NewBeam (int ent, vec3_t start, vec3_t end, model_t *m, int lightning);
1255 void CL_RelinkBeams (void);
1256 void CL_Beam_CalculatePositions (const beam_t *b, vec3_t start, vec3_t end);
1257 void CL_ClientMovement_Replay(void);
1258
1259 void CL_ClearTempEntities (void);
1260 entity_render_t *CL_NewTempEntity (double shadertime);
1261
1262 void CL_Effect(vec3_t org, model_t *model, int startframe, int framecount, float framerate);
1263
1264 void CL_ClearState (void);
1265 void CL_ExpandEntities(int num);
1266 void CL_ExpandCSQCRenderEntities(int num);
1267 void CL_SetInfo(const char *key, const char *value, qbool send, qbool allowstarkey, qbool allowmodel, qbool quiet);
1268
1269
1270 void CL_UpdateWorld (void);
1271 void CL_WriteToServer (void);
1272 void CL_Input (void);
1273 extern int cl_ignoremousemoves;
1274
1275
1276 float CL_KeyState (kbutton_t *key);
1277
1278 //
1279 // cl_cmd.c
1280 //
1281 /// adds the string as a clc_stringcmd to the client message.
1282 /// (used when there is no reason to generate a local command to do it)
1283 void CL_ForwardToServer (const char *s);
1284
1285 /// adds the current command line as a clc_stringcmd to the client message.
1286 /// things like godmode, noclip, etc, are commands directed to the server,
1287 /// so when they are typed in at the console, they will need to be forwarded.
1288 void CL_ForwardToServer_f (cmd_state_t *cmd);
1289 void CL_InitCommands(void);
1290
1291
1292 //
1293 // cl_demo.c
1294 //
1295 void CL_StopPlayback(void);
1296 void CL_ReadDemoMessage(void);
1297 void CL_WriteDemoMessage(sizebuf_t *mesage);
1298
1299 void CL_CutDemo(unsigned char **buf, fs_offset_t *filesize);
1300 void CL_PasteDemo(unsigned char **buf, fs_offset_t *filesize);
1301
1302 void CL_PlayDemo(const char *demo);
1303 void CL_NextDemo(void);
1304 void CL_Stop_f(cmd_state_t *cmd);
1305 void CL_Record_f(cmd_state_t *cmd);
1306 void CL_PlayDemo_f(cmd_state_t *cmd);
1307 void CL_TimeDemo_f(cmd_state_t *cmd);
1308
1309 void CL_Demo_Init(void);
1310
1311
1312 #include "cl_screen.h"
1313
1314 extern qbool sb_showscores;
1315
1316 typedef enum waterlevel_e
1317 {
1318         WATERLEVEL_NONE,
1319         WATERLEVEL_WETFEET,
1320         WATERLEVEL_SWIMMING,
1321         WATERLEVEL_SUBMERGED
1322 }
1323 waterlevel_t;
1324
1325 typedef struct cl_clientmovement_state_s
1326 {
1327         // entity to be ignored for movement
1328         struct prvm_edict_s *self;
1329         // position
1330         vec3_t origin;
1331         vec3_t velocity;
1332         // current bounding box (different if crouched vs standing)
1333         vec3_t mins;
1334         vec3_t maxs;
1335         // currently on the ground
1336         qbool onground;
1337         // currently crouching
1338         qbool crouched;
1339         // what kind of water (SUPERCONTENTS_LAVA for instance)
1340         int watertype;
1341         // how deep
1342         waterlevel_t waterlevel;
1343         // weird hacks when jumping out of water
1344         // (this is in seconds and counts down to 0)
1345         float waterjumptime;
1346
1347         // user command
1348         usercmd_t cmd;
1349 }
1350 cl_clientmovement_state_t;
1351 void CL_ClientMovement_PlayerMove_Frame(cl_clientmovement_state_t *s);
1352
1353 // warpzone prediction hack (CSQC builtin)
1354 void CL_RotateMoves(const matrix4x4_t *m);
1355
1356 typedef enum meshname_e {
1357         MESH_SCENE, // CSQC R_PolygonBegin, potentially also engine particles and debug stuff
1358         MESH_UI,
1359         NUM_MESHENTITIES,
1360 } meshname_t;
1361 extern entity_t cl_meshentities[NUM_MESHENTITIES];
1362 extern model_t cl_meshentitymodels[NUM_MESHENTITIES];
1363 extern const char *cl_meshentitynames[NUM_MESHENTITIES];
1364 #define CL_Mesh_Scene() (&cl_meshentitymodels[MESH_SCENE])
1365 #define CL_Mesh_UI() (&cl_meshentitymodels[MESH_UI])
1366 void CL_MeshEntities_Scene_Clear(void);
1367 void CL_MeshEntities_Scene_AddRenderEntity(void);
1368 void CL_MeshEntities_Scene_FinalizeRenderEntity(void);
1369 void CL_UpdateEntityShading(void);
1370
1371 void CL_NewFrameReceived(int num);
1372 void CL_ParseEntityLump(char *entitystring);
1373 void CL_FindNonSolidLocation(const vec3_t in, vec3_t out, vec_t radius);
1374 void CL_RelinkLightFlashes(void);
1375 void CL_Beam_AddPolygons(const beam_t *b);
1376 void CL_UpdateMoveVars(void);
1377 void CL_Locs_Reload_f(cmd_state_t *cmd);
1378
1379 #endif
1380