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
  28 // NOTE: r_stat_name[] must match this indexing
  29 typedef enum r_stat_e
  30 {
  31         r_stat_timedelta,
  32         r_stat_quality,
  33         r_stat_renders,
  34         r_stat_entities,
  35         r_stat_entities_surfaces,
  36         r_stat_entities_triangles,
  37         r_stat_world_leafs,
  38         r_stat_world_portals,
  39         r_stat_world_surfaces,
  40         r_stat_world_triangles,
  41         r_stat_lightmapupdates,
  42         r_stat_lightmapupdatepixels,
  43         r_stat_particles,
  44         r_stat_drawndecals,
  45         r_stat_totaldecals,
  46         r_stat_draws,
  47         r_stat_draws_vertices,
  48         r_stat_draws_elements,
  49         r_stat_lights,
  50         r_stat_lights_clears,
  51         r_stat_lights_scissored,
  52         r_stat_lights_lighttriangles,
  53         r_stat_lights_shadowtriangles,
  54         r_stat_lights_dynamicshadowtriangles,
  55         r_stat_bouncegrid_lights,
  56         r_stat_bouncegrid_particles,
  57         r_stat_bouncegrid_traces,
  58         r_stat_bouncegrid_hits,
  59         r_stat_bouncegrid_splats,
  60         r_stat_bouncegrid_bounces,
  61         r_stat_photoncache_animated,
  62         r_stat_photoncache_cached,
  63         r_stat_photoncache_traced,
  64         r_stat_bloom,
  65         r_stat_bloom_copypixels,
  66         r_stat_bloom_drawpixels,
  67         r_stat_indexbufferuploadcount,
  68         r_stat_indexbufferuploadsize,
  69         r_stat_vertexbufferuploadcount,
  70         r_stat_vertexbufferuploadsize,
  71         r_stat_framedatacurrent,
  72         r_stat_framedatasize,
  73         r_stat_bufferdatacurrent_vertex, // R_BUFFERDATA_ types are added to this index
  74         r_stat_bufferdatacurrent_index16,
  75         r_stat_bufferdatacurrent_index32,
  76         r_stat_bufferdatacurrent_uniform,
  77         r_stat_bufferdatasize_vertex, // R_BUFFERDATA_ types are added to this index
  78         r_stat_bufferdatasize_index16,
  79         r_stat_bufferdatasize_index32,
  80         r_stat_bufferdatasize_uniform,
  81         r_stat_animcache_vertexmesh_count,
  82         r_stat_animcache_vertexmesh_vertices,
  83         r_stat_animcache_vertexmesh_maxvertices,
  84         r_stat_animcache_skeletal_count,
  85         r_stat_animcache_skeletal_bones,
  86         r_stat_animcache_skeletal_maxbones,
  87         r_stat_animcache_shade_count,
  88         r_stat_animcache_shade_vertices,
  89         r_stat_animcache_shade_maxvertices,
  90         r_stat_animcache_shape_count,
  91         r_stat_animcache_shape_vertices,
  92         r_stat_animcache_shape_maxvertices,
  93         r_stat_batch_batches,
  94         r_stat_batch_withgaps,
  95         r_stat_batch_surfaces,
  96         r_stat_batch_vertices,
  97         r_stat_batch_triangles,
  98         r_stat_batch_fast_batches,
  99         r_stat_batch_fast_surfaces,
 100         r_stat_batch_fast_vertices,
 101         r_stat_batch_fast_triangles,
 102         r_stat_batch_copytriangles_batches,
 103         r_stat_batch_copytriangles_surfaces,
 104         r_stat_batch_copytriangles_vertices,
 105         r_stat_batch_copytriangles_triangles,
 106         r_stat_batch_dynamic_batches,
 107         r_stat_batch_dynamic_surfaces,
 108         r_stat_batch_dynamic_vertices,
 109         r_stat_batch_dynamic_triangles,
 110         r_stat_batch_dynamicskeletal_batches,
 111         r_stat_batch_dynamicskeletal_surfaces,
 112         r_stat_batch_dynamicskeletal_vertices,
 113         r_stat_batch_dynamicskeletal_triangles,
 114         r_stat_batch_dynamic_batches_because_cvar,
 115         r_stat_batch_dynamic_surfaces_because_cvar,
 116         r_stat_batch_dynamic_vertices_because_cvar,
 117         r_stat_batch_dynamic_triangles_because_cvar,
 118         r_stat_batch_dynamic_batches_because_lightmapvertex,
 119         r_stat_batch_dynamic_surfaces_because_lightmapvertex,
 120         r_stat_batch_dynamic_vertices_because_lightmapvertex,
 121         r_stat_batch_dynamic_triangles_because_lightmapvertex,
 122         r_stat_batch_dynamic_batches_because_deformvertexes_autosprite,
 123         r_stat_batch_dynamic_surfaces_because_deformvertexes_autosprite,
 124         r_stat_batch_dynamic_vertices_because_deformvertexes_autosprite,
 125         r_stat_batch_dynamic_triangles_because_deformvertexes_autosprite,
 126         r_stat_batch_dynamic_batches_because_deformvertexes_autosprite2,
 127         r_stat_batch_dynamic_surfaces_because_deformvertexes_autosprite2,
 128         r_stat_batch_dynamic_vertices_because_deformvertexes_autosprite2,
 129         r_stat_batch_dynamic_triangles_because_deformvertexes_autosprite2,
 130         r_stat_batch_dynamic_batches_because_deformvertexes_normal,
 131         r_stat_batch_dynamic_surfaces_because_deformvertexes_normal,
 132         r_stat_batch_dynamic_vertices_because_deformvertexes_normal,
 133         r_stat_batch_dynamic_triangles_because_deformvertexes_normal,
 134         r_stat_batch_dynamic_batches_because_deformvertexes_wave,
 135         r_stat_batch_dynamic_surfaces_because_deformvertexes_wave,
 136         r_stat_batch_dynamic_vertices_because_deformvertexes_wave,
 137         r_stat_batch_dynamic_triangles_because_deformvertexes_wave,
 138         r_stat_batch_dynamic_batches_because_deformvertexes_bulge,
 139         r_stat_batch_dynamic_surfaces_because_deformvertexes_bulge,
 140         r_stat_batch_dynamic_vertices_because_deformvertexes_bulge,
 141         r_stat_batch_dynamic_triangles_because_deformvertexes_bulge,
 142         r_stat_batch_dynamic_batches_because_deformvertexes_move,
 143         r_stat_batch_dynamic_surfaces_because_deformvertexes_move,
 144         r_stat_batch_dynamic_vertices_because_deformvertexes_move,
 145         r_stat_batch_dynamic_triangles_because_deformvertexes_move,
 146         r_stat_batch_dynamic_batches_because_tcgen_lightmap,
 147         r_stat_batch_dynamic_surfaces_because_tcgen_lightmap,
 148         r_stat_batch_dynamic_vertices_because_tcgen_lightmap,
 149         r_stat_batch_dynamic_triangles_because_tcgen_lightmap,
 150         r_stat_batch_dynamic_batches_because_tcgen_vector,
 151         r_stat_batch_dynamic_surfaces_because_tcgen_vector,
 152         r_stat_batch_dynamic_vertices_because_tcgen_vector,
 153         r_stat_batch_dynamic_triangles_because_tcgen_vector,
 154         r_stat_batch_dynamic_batches_because_tcgen_environment,
 155         r_stat_batch_dynamic_surfaces_because_tcgen_environment,
 156         r_stat_batch_dynamic_vertices_because_tcgen_environment,
 157         r_stat_batch_dynamic_triangles_because_tcgen_environment,
 158         r_stat_batch_dynamic_batches_because_tcmod_turbulent,
 159         r_stat_batch_dynamic_surfaces_because_tcmod_turbulent,
 160         r_stat_batch_dynamic_vertices_because_tcmod_turbulent,
 161         r_stat_batch_dynamic_triangles_because_tcmod_turbulent,
 162         r_stat_batch_dynamic_batches_because_interleavedarrays,
 163         r_stat_batch_dynamic_surfaces_because_interleavedarrays,
 164         r_stat_batch_dynamic_vertices_because_interleavedarrays,
 165         r_stat_batch_dynamic_triangles_because_interleavedarrays,
 166         r_stat_batch_dynamic_batches_because_nogaps,
 167         r_stat_batch_dynamic_surfaces_because_nogaps,
 168         r_stat_batch_dynamic_vertices_because_nogaps,
 169         r_stat_batch_dynamic_triangles_because_nogaps,
 170         r_stat_batch_dynamic_batches_because_derived,
 171         r_stat_batch_dynamic_surfaces_because_derived,
 172         r_stat_batch_dynamic_vertices_because_derived,
 173         r_stat_batch_dynamic_triangles_because_derived,
 174         r_stat_batch_entitycache_count,
 175         r_stat_batch_entitycache_surfaces,
 176         r_stat_batch_entitycache_vertices,
 177         r_stat_batch_entitycache_triangles,
 178         r_stat_batch_entityanimate_count,
 179         r_stat_batch_entityanimate_surfaces,
 180         r_stat_batch_entityanimate_vertices,
 181         r_stat_batch_entityanimate_triangles,
 182         r_stat_batch_entityskeletal_count,
 183         r_stat_batch_entityskeletal_surfaces,
 184         r_stat_batch_entityskeletal_vertices,
 185         r_stat_batch_entityskeletal_triangles,
 186         r_stat_batch_entitystatic_count,
 187         r_stat_batch_entitystatic_surfaces,
 188         r_stat_batch_entitystatic_vertices,
 189         r_stat_batch_entitystatic_triangles,
 190         r_stat_batch_entitycustom_count,
 191         r_stat_batch_entitycustom_surfaces,
 192         r_stat_batch_entitycustom_vertices,
 193         r_stat_batch_entitycustom_triangles,
 194         r_stat_count // size of array
 195 }
 196 r_stat_t;
 197
 198 // flags for rtlight rendering
 199 #define LIGHTFLAG_NORMALMODE 1
 200 #define LIGHTFLAG_REALTIMEMODE 2
 201
 202 typedef struct tridecal_s
 203 {
 204         // color and initial alpha value
 205         float                   texcoord2f[3][2];
 206         float                   vertex3f[3][3];
 207         float                   color4f[3][4];
 208         float                   plane[4]; // backface culling
 209         // how long this decal has lived so far (the actual fade begins at cl_decals_time)
 210         float                   lived;
 211         // if >= 0 this indicates the decal should follow an animated triangle
 212         int                             triangleindex;
 213         // for visibility culling
 214         int                             surfaceindex;
 215         // old decals are killed to obey cl_decals_max
 216         unsigned int    decalsequence;
 217 }
 218 tridecal_t;
 219
 220 typedef struct decalsystem_s
 221 {
 222         dp_model_t *model;
 223         double lastupdatetime;
 224         int maxdecals;
 225         int freedecal;
 226         int numdecals;
 227         tridecal_t *decals;
 228         float *vertex3f;
 229         float *texcoord2f;
 230         float *color4f;
 231         int *element3i;
 232         unsigned short *element3s;
 233 }
 234 decalsystem_t;
 235
 236 typedef struct effect_s
 237 {
 238         int active;
 239         vec3_t origin;
 240         double starttime;
 241         float framerate;
 242         int modelindex;
 243         int startframe;
 244         int endframe;
 245         // these are for interpolation
 246         int frame;
 247         double frame1time;
 248         double frame2time;
 249 }
 250 cl_effect_t;
 251
 252 typedef struct beam_s
 253 {
 254         int             entity;
 255         // draw this as lightning polygons, or a model?
 256         int             lightning;
 257         struct model_s  *model;
 258         float   endtime;
 259         vec3_t  start, end;
 260 }
 261 beam_t;
 262
 263 typedef struct rtlight_particle_s
 264 {
 265         float origin[3];
 266         float color[3];
 267 }
 268 rtlight_particle_t;
 269
 270 typedef struct rtlight_s
 271 {
 272         // shadow volumes are done entirely in model space, so there are no matrices for dealing with them...  they just use the origin
 273
 274         // note that the world to light matrices are inversely scaled (divided) by lightradius
 275
 276         // core properties
 277         /// matrix for transforming light filter coordinates to world coordinates
 278         matrix4x4_t matrix_lighttoworld;
 279         /// matrix for transforming world coordinates to light filter coordinates
 280         matrix4x4_t matrix_worldtolight;
 281         /// typically 1 1 1, can be lower (dim) or higher (overbright)
 282         vec3_t color;
 283         /// size of the light (remove?)
 284         vec_t radius;
 285         /// light filter
 286         char cubemapname[64];
 287         /// light style to monitor for brightness
 288         int style;
 289         /// whether light should render shadows (see castshadows for whether it actually does this frame)
 290         int shadow;
 291         /// intensity of corona to render
 292         vec_t corona;
 293         /// radius scale of corona to render (1.0 means same as light radius)
 294         vec_t coronasizescale;
 295         /// ambient intensity to render
 296         vec_t ambientscale;
 297         /// diffuse intensity to render
 298         vec_t diffusescale;
 299         /// specular intensity to render
 300         vec_t specularscale;
 301         /// LIGHTFLAG_* flags
 302         int flags;
 303
 304         // generated properties
 305         /// used only for shadow volumes
 306         vec3_t shadoworigin;
 307         /// culling
 308         vec3_t cullmins;
 309         vec3_t cullmaxs;
 310         /// when r_shadow_culllights_trace is set, this is refreshed by each successful trace.
 311         double trace_timer;
 312
 313         // rendering properties, updated each time a light is rendered
 314         // this is rtlight->color * d_lightstylevalue
 315         vec3_t currentcolor;
 316         /// used by corona updates, due to occlusion query
 317         float corona_visibility;
 318         unsigned int corona_queryindex_visiblepixels;
 319         unsigned int corona_queryindex_allpixels;
 320         /// this is R_GetCubemap(rtlight->cubemapname)
 321         rtexture_t *currentcubemap;
 322         /// set by R_Shadow_PrepareLight to decide whether R_Shadow_DrawLight should draw it
 323         qboolean draw;
 324         /// set by R_Shadow_PrepareLight to indicate whether R_Shadow_DrawShadowMaps should do anything
 325         qboolean castshadows;
 326         /// these fields are set by R_Shadow_PrepareLight for later drawing
 327         int cached_numlightentities;
 328         int cached_numlightentities_noselfshadow;
 329         int cached_numshadowentities;
 330         int cached_numshadowentities_noselfshadow;
 331         int cached_numsurfaces;
 332         struct entity_render_s **cached_lightentities;
 333         struct entity_render_s **cached_lightentities_noselfshadow;
 334         struct entity_render_s **cached_shadowentities;
 335         struct entity_render_s **cached_shadowentities_noselfshadow;
 336         unsigned char *cached_shadowtrispvs;
 337         unsigned char *cached_lighttrispvs;
 338         int *cached_surfacelist;
 339         // reduced light cullbox from GetLightInfo
 340         vec3_t cached_cullmins;
 341         vec3_t cached_cullmaxs;
 342         // current shadow-caster culling planes based on view
 343         // (any geometry outside these planes can not contribute to the visible
 344         //  shadows in any way, and thus can be culled safely)
 345         int cached_numfrustumplanes;
 346         mplane_t cached_frustumplanes[5]; // see R_Shadow_ComputeShadowCasterCullingPlanes
 347
 348         /// static light info
 349         /// true if this light should be compiled as a static light
 350         int isstatic;
 351         /// true if this is a compiled world light, cleared if the light changes
 352         int compiled;
 353         /// the shadowing mode used to compile this light
 354         int shadowmode;
 355         /// the size that this light should have (assuming no scene LOD kicking in to reduce it)
 356         int shadowmapsidesize;
 357         /// position of this light in the shadowmap atlas
 358         int shadowmapatlasposition[2];
 359         /// 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)
 360         int shadowmapatlassidesize;
 361         /// premade shadow volumes to render for world entity
 362         shadowmesh_t *static_meshchain_shadow_zpass;
 363         shadowmesh_t *static_meshchain_shadow_zfail;
 364         shadowmesh_t *static_meshchain_shadow_shadowmap;
 365         /// used for visibility testing (more exact than bbox)
 366         int static_numleafs;
 367         int static_numleafpvsbytes;
 368         int *static_leaflist;
 369         unsigned char *static_leafpvs;
 370         /// surfaces seen by light
 371         int static_numsurfaces;
 372         int *static_surfacelist;
 373         /// flag bits indicating which triangles of the world model should cast
 374         /// shadows, and which ones should be lit
 375         ///
 376         /// this avoids redundantly scanning the triangles in each surface twice
 377         /// for whether they should cast shadows, once in culling and once in the
 378         /// actual shadowmarklist production.
 379         int static_numshadowtrispvsbytes;
 380         unsigned char *static_shadowtrispvs;
 381         /// this allows the lighting batch code to skip backfaces andother culled
 382         /// triangles not relevant for lighting
 383         /// (important on big surfaces such as terrain)
 384         int static_numlighttrispvsbytes;
 385         unsigned char *static_lighttrispvs;
 386         /// masks of all shadowmap sides that have any potential static receivers or casters
 387         int static_shadowmap_receivers;
 388         int static_shadowmap_casters;
 389         /// particle-tracing cache for global illumination
 390         int particlecache_numparticles;
 391         int particlecache_maxparticles;
 392         int particlecache_updateparticle;
 393         rtlight_particle_t *particlecache_particles;
 394
 395         /// bouncegrid light info
 396         float bouncegrid_photoncolor[3];
 397         float bouncegrid_photons;
 398         int bouncegrid_hits;
 399         int bouncegrid_traces;
 400         float bouncegrid_effectiveradius;
 401 }
 402 rtlight_t;
 403
 404 typedef struct dlight_s
 405 {
 406         // destroy light after this time
 407         // (dlight only)
 408         vec_t die;
 409         // the entity that owns this light (can be NULL)
 410         // (dlight only)
 411         struct entity_render_s *ent;
 412         // location
 413         // (worldlight: saved to .rtlights file)
 414         vec3_t origin;
 415         // worldlight orientation
 416         // (worldlight only)
 417         // (worldlight: saved to .rtlights file)
 418         vec3_t angles;
 419         // dlight orientation/scaling/location
 420         // (dlight only)
 421         matrix4x4_t matrix;
 422         // color of light
 423         // (worldlight: saved to .rtlights file)
 424         vec3_t color;
 425         // cubemap name to use on this light
 426         // (worldlight: saved to .rtlights file)
 427         char cubemapname[64];
 428         // make light flash while selected
 429         // (worldlight only)
 430         int selected;
 431         // brightness (not really radius anymore)
 432         // (worldlight: saved to .rtlights file)
 433         vec_t radius;
 434         // drop intensity this much each second
 435         // (dlight only)
 436         vec_t decay;
 437         // intensity value which is dropped over time
 438         // (dlight only)
 439         vec_t intensity;
 440         // initial values for intensity to modify
 441         // (dlight only)
 442         vec_t initialradius;
 443         vec3_t initialcolor;
 444         // light style which controls intensity of this light
 445         // (worldlight: saved to .rtlights file)
 446         int style;
 447         // cast shadows
 448         // (worldlight: saved to .rtlights file)
 449         int shadow;
 450         // corona intensity
 451         // (worldlight: saved to .rtlights file)
 452         vec_t corona;
 453         // radius scale of corona to render (1.0 means same as light radius)
 454         // (worldlight: saved to .rtlights file)
 455         vec_t coronasizescale;
 456         // ambient intensity to render
 457         // (worldlight: saved to .rtlights file)
 458         vec_t ambientscale;
 459         // diffuse intensity to render
 460         // (worldlight: saved to .rtlights file)
 461         vec_t diffusescale;
 462         // specular intensity to render
 463         // (worldlight: saved to .rtlights file)
 464         vec_t specularscale;
 465         // LIGHTFLAG_* flags
 466         // (worldlight: saved to .rtlights file)
 467         int flags;
 468         // linked list of world lights
 469         // (worldlight only)
 470         struct dlight_s *next;
 471         // embedded rtlight struct for renderer
 472         // (worldlight only)
 473         rtlight_t rtlight;
 474 }
 475 dlight_t;
 476
 477 // this is derived from processing of the framegroupblend array
 478 // note: technically each framegroupblend can produce two of these, but that
 479 // never happens in practice because no one blends between more than 2
 480 // framegroups at once
 481 #define MAX_FRAMEBLENDS (MAX_FRAMEGROUPBLENDS * 2)
 482 typedef struct frameblend_s
 483 {
 484         int subframe;
 485         float lerp;
 486 }
 487 frameblend_t;
 488
 489 // LordHavoc: this struct is intended for the renderer but some fields are
 490 // used by the client.
 491 //
 492 // The renderer should not rely on any changes to this struct to be persistent
 493 // across multiple frames because temp entities are wiped every frame, but it
 494 // is acceptable to cache things in this struct that are not critical.
 495 //
 496 // For example the r_cullentities_trace code does such caching.
 497 typedef struct entity_render_s
 498 {
 499         // location
 500         //vec3_t origin;
 501         // orientation
 502         //vec3_t angles;
 503         // transform matrix for model to world
 504         matrix4x4_t matrix;
 505         // transform matrix for world to model
 506         matrix4x4_t inversematrix;
 507         // opacity (alpha) of the model
 508         float alpha;
 509         // size the model is shown
 510         float scale;
 511         // transparent sorting offset
 512         float transparent_offset;
 513
 514         // NULL = no model
 515         dp_model_t *model;
 516         // number of the entity represents, or 0 for non-network entities
 517         int entitynumber;
 518         // literal colormap colors for renderer, if both are 0 0 0 it is not colormapped
 519         vec3_t colormap_pantscolor;
 520         vec3_t colormap_shirtcolor;
 521         // light, particles, etc
 522         int effects;
 523         // qw CTF flags and other internal-use-only effect bits
 524         int internaleffects;
 525         // for Alias models
 526         int skinnum;
 527         // render flags
 528         int flags;
 529
 530         // colormod tinting of models
 531         float colormod[3];
 532         float glowmod[3];
 533
 534         // interpolated animation - active framegroups and blend factors
 535         framegroupblend_t framegroupblend[MAX_FRAMEGROUPBLENDS];
 536
 537         // time of last model change (for shader animations)
 538         double shadertime;
 539
 540         // calculated by the renderer (but not persistent)
 541
 542         // calculated during R_AddModelEntities
 543         vec3_t mins, maxs;
 544         // subframe numbers (-1 if not used) and their blending scalers (0-1), if interpolation is not desired, use subframeblend[0].subframe
 545         frameblend_t frameblend[MAX_FRAMEBLENDS];
 546         // skeletal animation data (if skeleton.relativetransforms is not NULL, it overrides frameblend)
 547         skeleton_t *skeleton;
 548
 549         // animation cache (pointers allocated using R_FrameData_Alloc)
 550         // ONLY valid during R_RenderView!  may be NULL (not cached)
 551         float          *animcache_vertex3f;
 552         r_meshbuffer_t *animcache_vertex3f_vertexbuffer;
 553         int             animcache_vertex3f_bufferoffset;
 554         float          *animcache_normal3f;
 555         r_meshbuffer_t *animcache_normal3f_vertexbuffer;
 556         int             animcache_normal3f_bufferoffset;
 557         float          *animcache_svector3f;
 558         r_meshbuffer_t *animcache_svector3f_vertexbuffer;
 559         int             animcache_svector3f_bufferoffset;
 560         float          *animcache_tvector3f;
 561         r_meshbuffer_t *animcache_tvector3f_vertexbuffer;
 562         int             animcache_tvector3f_bufferoffset;
 563         // interleaved arrays for rendering and dynamic vertex buffers for them
 564         r_vertexmesh_t *animcache_vertexmesh;
 565         r_meshbuffer_t *animcache_vertexmesh_vertexbuffer;
 566         int             animcache_vertexmesh_bufferoffset;
 567         // gpu-skinning shader needs transforms in a certain format, we have to
 568         // upload this to a uniform buffer for the shader to use, and also keep a
 569         // backup copy in system memory for the dynamic batch fallback code
 570         // if this is not NULL, the other animcache variables are NULL
 571         float *animcache_skeletaltransform3x4;
 572         r_meshbuffer_t *animcache_skeletaltransform3x4buffer;
 573         int animcache_skeletaltransform3x4offset;
 574         int animcache_skeletaltransform3x4size;
 575
 576         // current lighting from map (updated ONLY by client code, not renderer)
 577         vec3_t modellight_ambient;
 578         vec3_t modellight_diffuse; // q3bsp
 579         vec3_t modellight_lightdir; // q3bsp
 580
 581         // storage of decals on this entity
 582         // (note: if allowdecals is set, be sure to call R_DecalSystem_Reset on removal!)
 583         int allowdecals;
 584         decalsystem_t decalsystem;
 585
 586         // FIELDS UPDATED BY RENDERER:
 587         // last time visible during trace culling
 588         double last_trace_visibility;
 589
 590         // user wavefunc parameters (from csqc)
 591         vec_t userwavefunc_param[Q3WAVEFUNC_USER_COUNT];
 592 }
 593 entity_render_t;
 594
 595 typedef struct entity_persistent_s
 596 {
 597         vec3_t trail_origin; // previous position for particle trail spawning
 598         vec3_t oldorigin; // lerp
 599         vec3_t oldangles; // lerp
 600         vec3_t neworigin; // lerp
 601         vec3_t newangles; // lerp
 602         vec_t lerpstarttime; // lerp
 603         vec_t lerpdeltatime; // lerp
 604         float muzzleflash; // muzzleflash intensity, fades over time
 605         float trail_time; // residual error accumulation for particle trail spawning (to keep spacing across frames)
 606         qboolean trail_allowed; // set to false by teleports, true by update code, prevents bad lerps
 607 }
 608 entity_persistent_t;
 609
 610 typedef struct entity_s
 611 {
 612         // baseline state (default values)
 613         entity_state_t state_baseline;
 614         // previous state (interpolating from this)
 615         entity_state_t state_previous;
 616         // current state (interpolating to this)
 617         entity_state_t state_current;
 618
 619         // used for regenerating parts of render
 620         entity_persistent_t persistent;
 621
 622         // the only data the renderer should know about
 623         entity_render_t render;
 624 }
 625 entity_t;
 626
 627 typedef struct usercmd_s
 628 {
 629         vec3_t  viewangles;
 630
 631 // intended velocities
 632         float   forwardmove;
 633         float   sidemove;
 634         float   upmove;
 635
 636         vec3_t  cursor_screen;
 637         vec3_t  cursor_start;
 638         vec3_t  cursor_end;
 639         vec3_t  cursor_impact;
 640         vec3_t  cursor_normal;
 641         vec_t   cursor_fraction;
 642         int             cursor_entitynumber;
 643
 644         double time; // time the move is executed for (cl_movement: clienttime, non-cl_movement: receivetime)
 645         double receivetime; // time the move was received at
 646         double clienttime; // time to which server state the move corresponds to
 647         int msec; // for predicted moves
 648         int buttons;
 649         int impulse;
 650         unsigned int sequence;
 651         qboolean applied; // if false we're still accumulating a move
 652         qboolean predicted; // if true the sequence should be sent as 0
 653
 654         // derived properties
 655         double frametime;
 656         qboolean canjump;
 657         qboolean jump;
 658         qboolean crouch;
 659 } usercmd_t;
 660
 661 typedef struct lightstyle_s
 662 {
 663         int             length;
 664         char    map[MAX_STYLESTRING];
 665 } lightstyle_t;
 666
 667 typedef struct scoreboard_s
 668 {
 669         char    name[MAX_SCOREBOARDNAME];
 670         int             frags;
 671         int             colors; // two 4 bit fields
 672         // QW fields:
 673         int             qw_userid;
 674         char    qw_userinfo[MAX_USERINFO_STRING];
 675         float   qw_entertime;
 676         int             qw_ping;
 677         int             qw_packetloss;
 678         int             qw_movementloss;
 679         int             qw_spectator;
 680         char    qw_team[8];
 681         char    qw_skin[MAX_QPATH];
 682 } scoreboard_t;
 683
 684 typedef struct cshift_s
 685 {
 686         float   destcolor[3];
 687         float   percent;                // 0-255
 688         float   alphafade;      // (any speed)
 689 } cshift_t;
 690
 691 #define CSHIFT_CONTENTS 0
 692 #define CSHIFT_DAMAGE   1
 693 #define CSHIFT_BONUS    2
 694 #define CSHIFT_POWERUP  3
 695 #define CSHIFT_VCSHIFT  4
 696 #define NUM_CSHIFTS             5
 697
 698 #define NAME_LENGTH     64
 699
 700
 701 //
 702 // client_state_t should hold all pieces of the client state
 703 //
 704
 705 #define SIGNONS         4                       // signon messages to receive before connected
 706
 707 typedef enum cactive_e
 708 {
 709         ca_uninitialized,       // during early startup
 710         ca_dedicated,           // a dedicated server with no ability to start a client
 711         ca_disconnected,        // full screen console with no connection
 712         ca_connected            // valid netcon, talking to a server
 713 }
 714 cactive_t;
 715
 716 typedef enum qw_downloadtype_e
 717 {
 718         dl_none,
 719         dl_single,
 720         dl_skin,
 721         dl_model,
 722         dl_sound
 723 }
 724 qw_downloadtype_t;
 725
 726 typedef enum capturevideoformat_e
 727 {
 728         CAPTUREVIDEOFORMAT_AVI_I420,
 729         CAPTUREVIDEOFORMAT_OGG_VORBIS_THEORA
 730 }
 731 capturevideoformat_t;
 732
 733 typedef struct capturevideostate_s
 734 {
 735         double startrealtime;
 736         double framerate;
 737         int framestep;
 738         int framestepframe;
 739         qboolean active;
 740         qboolean realtime;
 741         qboolean error;
 742         int soundrate;
 743         int soundchannels;
 744         int frame;
 745         double starttime;
 746         double lastfpstime;
 747         int lastfpsframe;
 748         int soundsampleframe;
 749         unsigned char *screenbuffer;
 750         unsigned char *outbuffer;
 751         char basename[MAX_QPATH];
 752         int width, height;
 753
 754         // precomputed RGB to YUV tables
 755         // converts the RGB values to YUV (see cap_avi.c for how to use them)
 756         short rgbtoyuvscaletable[3][3][256];
 757         unsigned char yuvnormalizetable[3][256];
 758
 759         // precomputed gamma ramp (only needed if the capturevideo module uses RGB output)
 760         // note: to map from these values to RGB24, you have to multiply by 255.0/65535.0, then add 0.5, then cast to integer
 761         unsigned short vidramp[256 * 3];
 762
 763         // stuff to be filled in by the video format module
 764         capturevideoformat_t format;
 765         const char *formatextension;
 766         qfile_t *videofile;
 767                 // always use this:
 768                 //   cls.capturevideo.videofile = FS_OpenRealFile(va(vabuf, sizeof(vabuf), "%s.%s", cls.capturevideo.basename, cls.capturevideo.formatextension), "wb", false);
 769         void (*endvideo) (void);
 770         void (*videoframes) (int num);
 771         void (*soundframe) (const portable_sampleframe_t *paintbuffer, size_t length);
 772
 773         // format specific data
 774         void *formatspecific;
 775 }
 776 capturevideostate_t;
 777
 778 #define CL_MAX_DOWNLOADACKS 4
 779
 780 typedef struct cl_downloadack_s
 781 {
 782         int start, size;
 783 }
 784 cl_downloadack_t;
 785
 786 typedef struct cl_soundstats_s
 787 {
 788         int mixedsounds;
 789         int totalsounds;
 790         int latency_milliseconds;
 791 }
 792 cl_soundstats_t;
 793
 794 //
 795 // the client_static_t structure is persistent through an arbitrary number
 796 // of server connections
 797 //
 798 typedef struct client_static_s
 799 {
 800         cactive_t state;
 801
 802         // all client memory allocations go in these pools
 803         mempool_t *levelmempool;
 804         mempool_t *permanentmempool;
 805
 806 // demo loop control
 807         // -1 = don't play demos
 808         int demonum;
 809         // list of demos in loop
 810         char demos[MAX_DEMOS][MAX_DEMONAME];
 811         // the actively playing demo (set by CL_PlayDemo_f)
 812         char demoname[MAX_QPATH];
 813
 814 // demo recording info must be here, because record is started before
 815 // entering a map (and clearing client_state_t)
 816         qboolean demorecording;
 817         fs_offset_t demo_lastcsprogssize;
 818         int demo_lastcsprogscrc;
 819         qboolean demoplayback;
 820         qboolean demostarting; // set if currently starting a demo, to stop -demo from quitting when switching to another demo
 821         qboolean timedemo;
 822         // -1 = use normal cd track
 823         int forcetrack;
 824         qfile_t *demofile;
 825         // realtime at second frame of timedemo (LordHavoc: changed to double)
 826         double td_starttime;
 827         int td_frames; // total frames parsed
 828         double td_onesecondnexttime;
 829         double td_onesecondframes;
 830         double td_onesecondrealtime;
 831         double td_onesecondminfps;
 832         double td_onesecondmaxfps;
 833         double td_onesecondavgfps;
 834         int td_onesecondavgcount;
 835         // LordHavoc: pausedemo
 836         qboolean demopaused;
 837
 838         // sound mixer statistics for showsound display
 839         cl_soundstats_t soundstats;
 840
 841         qboolean connect_trying;
 842         int connect_remainingtries;
 843         double connect_nextsendtime;
 844         lhnetsocket_t *connect_mysocket;
 845         lhnetaddress_t connect_address;
 846         lhnetaddress_t rcon_address;
 847         // protocol version of the server we're connected to
 848         // (kept outside client_state_t because it's used between levels)
 849         protocolversion_t protocol;
 850
 851 #define MAX_RCONS 16
 852         int rcon_trying;
 853         lhnetaddress_t rcon_addresses[MAX_RCONS];
 854         char rcon_commands[MAX_RCONS][MAX_INPUTLINE];
 855         double rcon_timeout[MAX_RCONS];
 856         int rcon_ringpos;
 857
 858 // connection information
 859         // 0 to SIGNONS
 860         int signon;
 861         // network connection
 862         netconn_t *netcon;
 863
 864         // download information
 865         // (note: qw_download variables are also used)
 866         cl_downloadack_t dp_downloadack[CL_MAX_DOWNLOADACKS];
 867
 868         // input sequence numbers are not reset on level change, only connect
 869         unsigned int servermovesequence;
 870
 871         // quakeworld stuff below
 872
 873         // value of "qport" cvar at time of connection
 874         int qw_qport;
 875         // copied from cls.netcon->qw. variables every time they change, or set by demos (which have no cls.netcon)
 876         unsigned int qw_incoming_sequence;
 877         unsigned int qw_outgoing_sequence;
 878
 879         // current file download buffer (only saved when file is completed)
 880         char qw_downloadname[MAX_QPATH];
 881         unsigned char *qw_downloadmemory;
 882         int qw_downloadmemorycursize;
 883         int qw_downloadmemorymaxsize;
 884         int qw_downloadnumber;
 885         int qw_downloadpercent;
 886         qw_downloadtype_t qw_downloadtype;
 887         // transfer rate display
 888         double qw_downloadspeedtime;
 889         int qw_downloadspeedcount;
 890         int qw_downloadspeedrate;
 891         qboolean qw_download_deflate;
 892
 893         // current file upload buffer (for uploading screenshots to server)
 894         unsigned char *qw_uploaddata;
 895         int qw_uploadsize;
 896         int qw_uploadpos;
 897
 898         // user infostring
 899         // this normally contains the following keys in quakeworld:
 900         // password spectator name team skin topcolor bottomcolor rate noaim msg *ver *ip
 901         char userinfo[MAX_USERINFO_STRING];
 902
 903         // extra user info for the "connect" command
 904         char connect_userinfo[MAX_USERINFO_STRING];
 905
 906         // video capture stuff
 907         capturevideostate_t capturevideo;
 908
 909         // crypto channel
 910         crypto_t crypto;
 911
 912         // ProQuake compatibility stuff
 913         int proquake_servermod; // 0 = not proquake, 1 = proquake
 914         int proquake_serverversion; // actual proquake server version * 10 (3.40 = 34, etc)
 915         int proquake_serverflags; // 0 (PQF_CHEATFREE not supported)
 916
 917         // don't write-then-read csprogs.dat (useful for demo playback)
 918         unsigned char *caughtcsprogsdata;
 919         fs_offset_t caughtcsprogsdatasize;
 920
 921         int r_speeds_graph_length;
 922         int r_speeds_graph_current;
 923         int *r_speeds_graph_data;
 924
 925         // graph scales
 926         int r_speeds_graph_datamin[r_stat_count];
 927         int r_speeds_graph_datamax[r_stat_count];
 928 }
 929 client_static_t;
 930
 931 extern client_static_t  cls;
 932
 933 //[515]: csqc
 934 typedef struct
 935 {
 936         qboolean drawworld;
 937         qboolean drawenginesbar;
 938         qboolean drawcrosshair;
 939 }csqc_vidvars_t;
 940
 941 typedef enum
 942 {
 943         PARTICLE_BILLBOARD = 0,
 944         PARTICLE_SPARK = 1,
 945         PARTICLE_ORIENTED_DOUBLESIDED = 2,
 946         PARTICLE_VBEAM = 3,
 947         PARTICLE_HBEAM = 4,
 948         PARTICLE_INVALID = -1
 949 }
 950 porientation_t;
 951
 952 typedef enum
 953 {
 954         PBLEND_ALPHA = 0,
 955         PBLEND_ADD = 1,
 956         PBLEND_INVMOD = 2,
 957         PBLEND_INVALID = -1
 958 }
 959 pblend_t;
 960
 961 typedef struct particletype_s
 962 {
 963         pblend_t blendmode;
 964         porientation_t orientation;
 965         qboolean lighting;
 966 }
 967 particletype_t;
 968
 969 typedef enum ptype_e
 970 {
 971         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
 972 }
 973 ptype_t;
 974
 975 typedef struct decal_s
 976 {
 977         // fields used by rendering:  (44 bytes)
 978         unsigned short  typeindex;
 979         unsigned short  texnum;
 980         unsigned int    decalsequence;
 981         vec3_t                  org;
 982         vec3_t                  normal;
 983         float                   size;
 984         float                   alpha; // 0-255
 985         unsigned char   color[3];
 986         unsigned char   unused1;
 987         int                             clusterindex; // cheap culling by pvs
 988
 989         // fields not used by rendering: (36 bytes in 32bit, 40 bytes in 64bit)
 990         float                   time2; // used for decal fade
 991         unsigned int    owner; // decal stuck to this entity
 992         dp_model_t                      *ownermodel; // model the decal is stuck to (used to make sure the entity is still alive)
 993         vec3_t                  relativeorigin; // decal at this location in entity's coordinate space
 994         vec3_t                  relativenormal; // decal oriented this way relative to entity's coordinate space
 995 }
 996 decal_t;
 997
 998 typedef struct particle_s
 999 {
1000         // for faster batch rendering, particles are rendered in groups by effect (resulting in less perfect sorting but far less state changes)
1001
1002         // fields used by rendering: (48 bytes)
1003         vec3_t          sortorigin; // sort by this group origin, not particle org
1004         vec3_t          org;
1005         vec3_t          vel; // velocity of particle, or orientation of decal, or end point of beam
1006         float           size;
1007         float           alpha; // 0-255
1008         float           stretch; // only for sparks
1009
1010         // fields not used by rendering:  (44 bytes)
1011         float           stainsize;
1012         float           stainalpha;
1013         float           sizeincrease; // rate of size change per second
1014         float           alphafade; // how much alpha reduces per second
1015         float           time2; // used for snow fluttering and decal fade
1016         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)
1017         float           gravity; // how much gravity affects this particle (1.0 = normal gravity, 0.0 = none)
1018         float           airfriction; // how much air friction affects this object (objects with a low mass/size ratio tend to get more air friction)
1019         float           liquidfriction; // how much liquid friction affects this object (objects with a low mass/size ratio tend to get more liquid friction)
1020 //      float           delayedcollisions; // time that p->bounce becomes active
1021         float           delayedspawn; // time that particle appears and begins moving
1022         float           die; // time when this particle should be removed, regardless of alpha
1023
1024         // short variables grouped to save memory (4 bytes)
1025         short                   angle; // base rotation of particle
1026         short                   spin; // geometry rotation speed around the particle center normal
1027
1028         // byte variables grouped to save memory (12 bytes)
1029         unsigned char   color[3];
1030         unsigned char   qualityreduction; // enables skipping of this particle according to r_refdef.view.qualityreduction
1031         unsigned char   typeindex;
1032         unsigned char   blendmode;
1033         unsigned char   orientation;
1034         unsigned char   texnum;
1035         unsigned char   staincolor[3];
1036         signed char     staintexnum;
1037 }
1038 particle_t;
1039
1040 typedef enum cl_parsingtextmode_e
1041 {
1042         CL_PARSETEXTMODE_NONE,
1043         CL_PARSETEXTMODE_PING,
1044         CL_PARSETEXTMODE_STATUS,
1045         CL_PARSETEXTMODE_STATUS_PLAYERID,
1046         CL_PARSETEXTMODE_STATUS_PLAYERIP
1047 }
1048 cl_parsingtextmode_t;
1049
1050 typedef struct cl_locnode_s
1051 {
1052         struct cl_locnode_s *next;
1053         char *name;
1054         vec3_t mins, maxs;
1055 }
1056 cl_locnode_t;
1057
1058 typedef struct showlmp_s
1059 {
1060         qboolean        isactive;
1061         float           x;
1062         float           y;
1063         char            label[32];
1064         char            pic[128];
1065 }
1066 showlmp_t;
1067
1068 //
1069 // the client_state_t structure is wiped completely at every
1070 // server signon
1071 //
1072 typedef struct client_state_s
1073 {
1074         // true if playing in a local game and no one else is connected
1075         int islocalgame;
1076
1077         // send a clc_nop periodically until connected
1078         float sendnoptime;
1079
1080         // current input being accumulated by mouse/joystick/etc input
1081         usercmd_t cmd;
1082         // latest moves sent to the server that have not been confirmed yet
1083         usercmd_t movecmd[CL_MAX_USERCMDS];
1084
1085 // information for local display
1086         // health, etc
1087         int stats[MAX_CL_STATS];
1088         float *statsf; // points to stats[] array
1089         // last known inventory bit flags, for blinking
1090         int olditems;
1091         // cl.time of acquiring item, for blinking
1092         float item_gettime[32];
1093         // last known STAT_ACTIVEWEAPON
1094         int activeweapon;
1095         // cl.time of changing STAT_ACTIVEWEAPON
1096         float weapontime;
1097         // use pain anim frame if cl.time < this
1098         float faceanimtime;
1099         // for stair smoothing
1100         float stairsmoothz;
1101         double stairsmoothtime;
1102
1103         // color shifts for damage, powerups
1104         cshift_t cshifts[NUM_CSHIFTS];
1105         // and content types
1106         cshift_t prev_cshifts[NUM_CSHIFTS];
1107
1108 // the client maintains its own idea of view angles, which are
1109 // sent to the server each frame.  The server sets punchangle when
1110 // the view is temporarily offset, and an angle reset commands at the start
1111 // of each level and after teleporting.
1112
1113         // mviewangles is read from demo
1114         // viewangles is either client controlled or lerped from mviewangles
1115         vec3_t mviewangles[2], viewangles;
1116         // update by server, used by qc to do weapon recoil
1117         vec3_t mpunchangle[2], punchangle;
1118         // update by server, can be used by mods to kick view around
1119         vec3_t mpunchvector[2], punchvector;
1120         // update by server, used for lean+bob (0 is newest)
1121         vec3_t mvelocity[2], velocity;
1122         // update by server, can be used by mods for zooming
1123         vec_t mviewzoom[2], viewzoom;
1124         // if true interpolation the mviewangles and other interpolation of the
1125         // player is disabled until the next network packet
1126         // this is used primarily by teleporters, and when spectating players
1127         // special checking of the old fixangle[1] is used to differentiate
1128         // between teleporting and spectating
1129         qboolean fixangle[2];
1130
1131         // client movement simulation
1132         // these fields are only updated by CL_ClientMovement (called by CL_SendMove after parsing each network packet)
1133         // set by CL_ClientMovement_Replay functions
1134         qboolean movement_predicted;
1135         // if true the CL_ClientMovement_Replay function will update origin, etc
1136         qboolean movement_replay;
1137         // simulated data (this is valid even if cl.movement is false)
1138         vec3_t movement_origin;
1139         vec3_t movement_velocity;
1140         // whether the replay should allow a jump at the first sequence
1141         qboolean movement_replay_canjump;
1142
1143         // previous gun angles (for leaning effects)
1144         vec3_t gunangles_prev;
1145         vec3_t gunangles_highpass;
1146         vec3_t gunangles_adjustment_lowpass;
1147         vec3_t gunangles_adjustment_highpass;
1148         // previous gun angles (for leaning effects)
1149         vec3_t gunorg_prev;
1150         vec3_t gunorg_highpass;
1151         vec3_t gunorg_adjustment_lowpass;
1152         vec3_t gunorg_adjustment_highpass;
1153
1154 // pitch drifting vars
1155         float idealpitch;
1156         float pitchvel;
1157         qboolean nodrift;
1158         float driftmove;
1159         double laststop;
1160
1161 //[515]: added for csqc purposes
1162         float sensitivityscale;
1163         csqc_vidvars_t csqc_vidvars;    //[515]: these parms must be set to true by default
1164         qboolean csqc_wantsmousemove;
1165         qboolean csqc_paused; // vortex: int because could be flags
1166         struct model_s *csqc_model_precache[MAX_MODELS];
1167
1168         // local amount for smoothing stepups
1169         //float crouch;
1170
1171         // sent by server
1172         qboolean paused;
1173         qboolean onground;
1174         qboolean inwater;
1175
1176         // used by bob
1177         qboolean oldonground;
1178         double lastongroundtime;
1179         double hitgroundtime;
1180         float bob2_smooth;
1181         float bobfall_speed;
1182         float bobfall_swing;
1183         double calcrefdef_prevtime;
1184
1185         // don't change view angle, full screen, etc
1186         int intermission;
1187         // latched at intermission start
1188         double completed_time;
1189
1190         // the timestamp of the last two messages
1191         double mtime[2];
1192
1193         // clients view of time, time should be between mtime[0] and mtime[1] to
1194         // generate a lerp point for other data, oldtime is the previous frame's
1195         // value of time, frametime is the difference between time and oldtime
1196         // note: cl.time may be beyond cl.mtime[0] if packet loss is occuring, it
1197         // is only forcefully limited when a packet is received
1198         double time, oldtime;
1199         // how long it has been since the previous client frame in real time
1200         // (not game time, for that use cl.time - cl.oldtime)
1201         double realframetime;
1202
1203         // fade var for fading while dead
1204         float deathfade;
1205
1206         // motionblur alpha level variable
1207         float motionbluralpha;
1208
1209         // copy of realtime from last recieved message, for net trouble icon
1210         float last_received_message;
1211
1212 // information that is static for the entire time connected to a server
1213         struct model_s *model_precache[MAX_MODELS];
1214         struct sfx_s *sound_precache[MAX_SOUNDS];
1215
1216         // FIXME: this is a lot of memory to be keeping around, this really should be dynamically allocated and freed somehow
1217         char model_name[MAX_MODELS][MAX_QPATH];
1218         char sound_name[MAX_SOUNDS][MAX_QPATH];
1219
1220         // for display on solo scoreboard
1221         char worldmessage[40]; // map title (not related to filename)
1222         // variants of map name
1223         char worldbasename[MAX_QPATH]; // %s
1224         char worldname[MAX_QPATH]; // maps/%s.bsp
1225         char worldnamenoextension[MAX_QPATH]; // maps/%s
1226         // cl_entitites[cl.viewentity] = player
1227         int viewentity;
1228         // the real player entity (normally same as viewentity,
1229         // different than viewentity if mod uses chasecam or other tricks)
1230         int realplayerentity;
1231         // this is updated to match cl.viewentity whenever it is in the clients
1232         // range, basically this is used in preference to cl.realplayerentity for
1233         // most purposes because when spectating another player it should show
1234         // their information rather than yours
1235         int playerentity;
1236         // max players that can be in this game
1237         int maxclients;
1238         // type of game (deathmatch, coop, singleplayer)
1239         int gametype;
1240
1241         // models and sounds used by engine code (particularly cl_parse.c)
1242         dp_model_t *model_bolt;
1243         dp_model_t *model_bolt2;
1244         dp_model_t *model_bolt3;
1245         dp_model_t *model_beam;
1246         sfx_t *sfx_wizhit;
1247         sfx_t *sfx_knighthit;
1248         sfx_t *sfx_tink1;
1249         sfx_t *sfx_ric1;
1250         sfx_t *sfx_ric2;
1251         sfx_t *sfx_ric3;
1252         sfx_t *sfx_r_exp3;
1253         // indicates that the file "sound/misc/talk2.wav" was found (for use by team chat messages)
1254         qboolean foundtalk2wav;
1255
1256 // refresh related state
1257
1258         // cl_entitites[0].model
1259         struct model_s *worldmodel;
1260
1261         // the gun model
1262         entity_t viewent;
1263
1264         // cd audio
1265         int cdtrack, looptrack;
1266
1267 // frag scoreboard
1268
1269         // [cl.maxclients]
1270         scoreboard_t *scores;
1271
1272         // keep track of svc_print parsing state (analyzes ping reports and status reports)
1273         cl_parsingtextmode_t parsingtextmode;
1274         int parsingtextplayerindex;
1275         // set by scoreboard code when sending ping command, this causes the next ping results to be hidden
1276         // (which could eat the wrong ping report if the player issues one
1277         //  manually, but they would still see a ping report, just a later one
1278         //  caused by the scoreboard code rather than the one they intentionally
1279         //  issued)
1280         int parsingtextexpectingpingforscores;
1281
1282         // entity database stuff
1283         // latest received entity frame numbers
1284 #define LATESTFRAMENUMS 32
1285         int latestframenumsposition;
1286         int latestframenums[LATESTFRAMENUMS];
1287         unsigned int latestsendnums[LATESTFRAMENUMS];
1288         entityframe_database_t *entitydatabase;
1289         entityframe4_database_t *entitydatabase4;
1290         entityframeqw_database_t *entitydatabaseqw;
1291
1292         // keep track of quake entities because they need to be killed if they get stale
1293         int lastquakeentity;
1294         unsigned char isquakeentity[MAX_EDICTS];
1295
1296         // bounding boxes for clientside movement
1297         vec3_t playerstandmins;
1298         vec3_t playerstandmaxs;
1299         vec3_t playercrouchmins;
1300         vec3_t playercrouchmaxs;
1301
1302         // old decals are killed based on this
1303         unsigned int decalsequence;
1304
1305         int max_entities;
1306         int max_csqcrenderentities;
1307         int max_static_entities;
1308         int max_effects;
1309         int max_beams;
1310         int max_dlights;
1311         int max_lightstyle;
1312         int max_brushmodel_entities;
1313         int max_particles;
1314         int max_decals;
1315         int max_showlmps;
1316
1317         entity_t *entities;
1318         entity_render_t *csqcrenderentities;
1319         unsigned char *entities_active;
1320         entity_t *static_entities;
1321         cl_effect_t *effects;
1322         beam_t *beams;
1323         dlight_t *dlights;
1324         lightstyle_t *lightstyle;
1325         int *brushmodel_entities;
1326         particle_t *particles;
1327         decal_t *decals;
1328         showlmp_t *showlmps;
1329
1330         int num_entities;
1331         int num_static_entities;
1332         int num_brushmodel_entities;
1333         int num_effects;
1334         int num_beams;
1335         int num_dlights;
1336         int num_particles;
1337         int num_decals;
1338         int num_showlmps;
1339
1340         double particles_updatetime;
1341         double decals_updatetime;
1342         int free_particle;
1343         int free_decal;
1344
1345         // cl_serverextension_download feature
1346         int loadmodel_current;
1347         int downloadmodel_current;
1348         int loadmodel_total;
1349         int loadsound_current;
1350         int downloadsound_current;
1351         int loadsound_total;
1352         qboolean downloadcsqc;
1353         qboolean loadcsqc;
1354         qboolean loadbegun;
1355         qboolean loadfinished;
1356
1357         // quakeworld stuff
1358
1359         // local copy of the server infostring
1360         char qw_serverinfo[MAX_SERVERINFO_STRING];
1361
1362         // time of last qw "pings" command sent to server while showing scores
1363         double last_ping_request;
1364
1365         // used during connect
1366         int qw_servercount;
1367
1368         // updated from serverinfo
1369         int qw_teamplay;
1370
1371         // unused: indicates whether the player is spectating
1372         // use cl.scores[cl.playerentity-1].qw_spectator instead
1373         //qboolean qw_spectator;
1374
1375         // last time an input packet was sent
1376         double lastpackettime;
1377
1378         // movement parameters for client prediction
1379         unsigned int moveflags;
1380         float movevars_wallfriction;
1381         float movevars_waterfriction;
1382         float movevars_friction;
1383         float movevars_timescale;
1384         float movevars_gravity;
1385         float movevars_stopspeed;
1386         float movevars_maxspeed;
1387         float movevars_spectatormaxspeed;
1388         float movevars_accelerate;
1389         float movevars_airaccelerate;
1390         float movevars_wateraccelerate;
1391         float movevars_entgravity;
1392         float movevars_jumpvelocity;
1393         float movevars_edgefriction;
1394         float movevars_maxairspeed;
1395         float movevars_stepheight;
1396         float movevars_airaccel_qw;
1397         float movevars_airaccel_qw_stretchfactor;
1398         float movevars_airaccel_sideways_friction;
1399         float movevars_airstopaccelerate;
1400         float movevars_airstrafeaccelerate;
1401         float movevars_maxairstrafespeed;
1402         float movevars_airstrafeaccel_qw;
1403         float movevars_aircontrol;
1404         float movevars_aircontrol_power;
1405         float movevars_aircontrol_penalty;
1406         float movevars_warsowbunny_airforwardaccel;
1407         float movevars_warsowbunny_accel;
1408         float movevars_warsowbunny_topspeed;
1409         float movevars_warsowbunny_turnaccel;
1410         float movevars_warsowbunny_backtosideratio;
1411         float movevars_ticrate;
1412         float movevars_airspeedlimit_nonqw;
1413
1414         // models used by qw protocol
1415         int qw_modelindex_spike;
1416         int qw_modelindex_player;
1417         int qw_modelindex_flag;
1418         int qw_modelindex_s_explod;
1419
1420         vec3_t qw_intermission_origin;
1421         vec3_t qw_intermission_angles;
1422
1423         // 255 is the most nails the QW protocol could send
1424         int qw_num_nails;
1425         vec_t qw_nails[255][6];
1426
1427         float qw_weaponkick;
1428
1429         unsigned int qw_validsequence;
1430
1431         unsigned int qw_deltasequence[QW_UPDATE_BACKUP];
1432
1433         // csqc stuff:
1434         // server entity number corresponding to a clientside entity
1435         unsigned short csqc_server2csqcentitynumber[MAX_EDICTS];
1436         qboolean csqc_loaded;
1437         vec3_t csqc_vieworigin;
1438         vec3_t csqc_viewangles;
1439         vec3_t csqc_vieworiginfromengine;
1440         vec3_t csqc_viewanglesfromengine;
1441         matrix4x4_t csqc_viewmodelmatrixfromengine;
1442         qboolean csqc_usecsqclistener;
1443         matrix4x4_t csqc_listenermatrix;
1444         char csqc_printtextbuf[MAX_INPUTLINE];
1445
1446         // collision culling data
1447         world_t world;
1448
1449         // loc file stuff (points and boxes describing locations in the level)
1450         cl_locnode_t *locnodes;
1451         // this is updated to cl.movement_origin whenever health is < 1
1452         // used by %d print in say/say_team messages if cl_locs_enable is on
1453         vec3_t lastdeathorigin;
1454
1455         // processing buffer used by R_BuildLightMap, reallocated as needed,
1456         // freed on each level change
1457         size_t buildlightmapmemorysize;
1458         unsigned char *buildlightmapmemory;
1459
1460         // used by EntityState5_ReadUpdate
1461         skeleton_t *engineskeletonobjects;
1462 }
1463 client_state_t;
1464
1465 //
1466 // cvars
1467 //
1468 extern cvar_t cl_name;
1469 extern cvar_t cl_color;
1470 extern cvar_t cl_rate;
1471 extern cvar_t cl_rate_burstsize;
1472 extern cvar_t cl_pmodel;
1473 extern cvar_t cl_playermodel;
1474 extern cvar_t cl_playerskin;
1475
1476 extern cvar_t rcon_password;
1477 extern cvar_t rcon_address;
1478
1479 extern cvar_t cl_upspeed;
1480 extern cvar_t cl_forwardspeed;
1481 extern cvar_t cl_backspeed;
1482 extern cvar_t cl_sidespeed;
1483
1484 extern cvar_t cl_movespeedkey;
1485
1486 extern cvar_t cl_yawspeed;
1487 extern cvar_t cl_pitchspeed;
1488
1489 extern cvar_t cl_anglespeedkey;
1490
1491 extern cvar_t cl_autofire;
1492
1493 extern cvar_t cl_shownet;
1494 extern cvar_t cl_nolerp;
1495 extern cvar_t cl_nettimesyncfactor;
1496 extern cvar_t cl_nettimesyncboundmode;
1497 extern cvar_t cl_nettimesyncboundtolerance;
1498
1499 extern cvar_t cl_pitchdriftspeed;
1500 extern cvar_t lookspring;
1501 extern cvar_t lookstrafe;
1502 extern cvar_t sensitivity;
1503
1504 extern cvar_t freelook;
1505
1506 extern cvar_t m_pitch;
1507 extern cvar_t m_yaw;
1508 extern cvar_t m_forward;
1509 extern cvar_t m_side;
1510
1511 extern cvar_t cl_autodemo;
1512 extern cvar_t cl_autodemo_nameformat;
1513 extern cvar_t cl_autodemo_delete;
1514
1515 extern cvar_t r_draweffects;
1516
1517 extern cvar_t cl_explosions_alpha_start;
1518 extern cvar_t cl_explosions_alpha_end;
1519 extern cvar_t cl_explosions_size_start;
1520 extern cvar_t cl_explosions_size_end;
1521 extern cvar_t cl_explosions_lifetime;
1522 extern cvar_t cl_stainmaps;
1523 extern cvar_t cl_stainmaps_clearonload;
1524
1525 extern cvar_t cl_prydoncursor;
1526 extern cvar_t cl_prydoncursor_notrace;
1527
1528 extern cvar_t cl_locs_enable;
1529
1530 extern client_state_t cl;
1531
1532 extern void CL_AllocLightFlash (entity_render_t *ent, matrix4x4_t *matrix, float radius, float red, float green, float blue, float decay, float lifetime, int cubemapnum, int style, int shadowenable, vec_t corona, vec_t coronasizescale, vec_t ambientscale, vec_t diffusescale, vec_t specularscale, int flags);
1533
1534 cl_locnode_t *CL_Locs_FindNearest(const vec3_t point);
1535 void CL_Locs_FindLocationName(char *buffer, size_t buffersize, vec3_t point);
1536
1537 //=============================================================================
1538
1539 //
1540 // cl_main
1541 //
1542
1543 void CL_Shutdown (void);
1544 void CL_Init (void);
1545
1546 void CL_EstablishConnection(const char *host, int firstarg);
1547
1548 void CL_Disconnect (void);
1549 void CL_Disconnect_f (void);
1550
1551 void CL_UpdateRenderEntity(entity_render_t *ent);
1552 void CL_SetEntityColormapColors(entity_render_t *ent, int colormap);
1553 void CL_UpdateViewEntities(void);
1554
1555 //
1556 // cl_input
1557 //
1558 typedef struct kbutton_s
1559 {
1560         int             down[2];                // key nums holding it down
1561         int             state;                  // low bit is down state
1562 }
1563 kbutton_t;
1564
1565 extern  kbutton_t       in_mlook, in_klook;
1566 extern  kbutton_t       in_strafe;
1567 extern  kbutton_t       in_speed;
1568
1569 void CL_InitInput (void);
1570 void CL_SendMove (void);
1571
1572 void CL_ValidateState(entity_state_t *s);
1573 void CL_MoveLerpEntityStates(entity_t *ent);
1574 void CL_LerpUpdate(entity_t *e);
1575 void CL_ParseTEnt (void);
1576 void CL_NewBeam (int ent, vec3_t start, vec3_t end, dp_model_t *m, int lightning);
1577 void CL_RelinkBeams (void);
1578 void CL_Beam_CalculatePositions (const beam_t *b, vec3_t start, vec3_t end);
1579 void CL_ClientMovement_Replay(void);
1580
1581 void CL_ClearTempEntities (void);
1582 entity_render_t *CL_NewTempEntity (double shadertime);
1583
1584 void CL_Effect(vec3_t org, int modelindex, int startframe, int framecount, float framerate);
1585
1586 void CL_ClearState (void);
1587 void CL_ExpandEntities(int num);
1588 void CL_ExpandCSQCRenderEntities(int num);
1589 void CL_SetInfo(const char *key, const char *value, qboolean send, qboolean allowstarkey, qboolean allowmodel, qboolean quiet);
1590
1591
1592 void CL_UpdateWorld (void);
1593 void CL_WriteToServer (void);
1594 void CL_Input (void);
1595 extern int cl_ignoremousemoves;
1596
1597
1598 float CL_KeyState (kbutton_t *key);
1599 const char *Key_KeynumToString (int keynum, char *buf, size_t buflength);
1600 int Key_StringToKeynum (const char *str);
1601
1602 //
1603 // cl_demo.c
1604 //
1605 void CL_StopPlayback(void);
1606 void CL_ReadDemoMessage(void);
1607 void CL_WriteDemoMessage(sizebuf_t *mesage);
1608
1609 void CL_CutDemo(unsigned char **buf, fs_offset_t *filesize);
1610 void CL_PasteDemo(unsigned char **buf, fs_offset_t *filesize);
1611
1612 void CL_NextDemo(void);
1613 void CL_Stop_f(void);
1614 void CL_Record_f(void);
1615 void CL_PlayDemo_f(void);
1616 void CL_TimeDemo_f(void);
1617
1618 //
1619 // cl_parse.c
1620 //
1621 void CL_Parse_Init(void);
1622 void CL_Parse_Shutdown(void);
1623 void CL_ParseServerMessage(void);
1624 void CL_Parse_DumpPacket(void);
1625 void CL_Parse_ErrorCleanUp(void);
1626 void QW_CL_StartUpload(unsigned char *data, int size);
1627 extern cvar_t qport;
1628 void CL_KeepaliveMessage(qboolean readmessages); // call this during loading of large content
1629
1630 //
1631 // view
1632 //
1633 void V_StartPitchDrift (void);
1634 void V_StopPitchDrift (void);
1635
1636 void V_Init (void);
1637 float V_CalcRoll (const vec3_t angles, const vec3_t velocity);
1638 void V_UpdateBlends (void);
1639 void V_ParseDamage (void);
1640
1641 //
1642 // cl_part
1643 //
1644
1645 extern cvar_t cl_particles;
1646 extern cvar_t cl_particles_quality;
1647 extern cvar_t cl_particles_size;
1648 extern cvar_t cl_particles_quake;
1649 extern cvar_t cl_particles_blood;
1650 extern cvar_t cl_particles_blood_alpha;
1651 extern cvar_t cl_particles_blood_decal_alpha;
1652 extern cvar_t cl_particles_blood_decal_scalemin;
1653 extern cvar_t cl_particles_blood_decal_scalemax;
1654 extern cvar_t cl_particles_blood_bloodhack;
1655 extern cvar_t cl_particles_bulletimpacts;
1656 extern cvar_t cl_particles_explosions_sparks;
1657 extern cvar_t cl_particles_explosions_shell;
1658 extern cvar_t cl_particles_rain;
1659 extern cvar_t cl_particles_snow;
1660 extern cvar_t cl_particles_smoke;
1661 extern cvar_t cl_particles_smoke_alpha;
1662 extern cvar_t cl_particles_smoke_alphafade;
1663 extern cvar_t cl_particles_sparks;
1664 extern cvar_t cl_particles_bubbles;
1665 extern cvar_t cl_decals;
1666 extern cvar_t cl_decals_time;
1667 extern cvar_t cl_decals_fadetime;
1668
1669 void CL_Particles_Clear(void);
1670 void CL_Particles_Init(void);
1671 void CL_Particles_Shutdown(void);
1672 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]);
1673
1674 typedef enum effectnameindex_s
1675 {
1676         EFFECT_NONE,
1677         EFFECT_TE_GUNSHOT,
1678         EFFECT_TE_GUNSHOTQUAD,
1679         EFFECT_TE_SPIKE,
1680         EFFECT_TE_SPIKEQUAD,
1681         EFFECT_TE_SUPERSPIKE,
1682         EFFECT_TE_SUPERSPIKEQUAD,
1683         EFFECT_TE_WIZSPIKE,
1684         EFFECT_TE_KNIGHTSPIKE,
1685         EFFECT_TE_EXPLOSION,
1686         EFFECT_TE_EXPLOSIONQUAD,
1687         EFFECT_TE_TAREXPLOSION,
1688         EFFECT_TE_TELEPORT,
1689         EFFECT_TE_LAVASPLASH,
1690         EFFECT_TE_SMALLFLASH,
1691         EFFECT_TE_FLAMEJET,
1692         EFFECT_EF_FLAME,
1693         EFFECT_TE_BLOOD,
1694         EFFECT_TE_SPARK,
1695         EFFECT_TE_PLASMABURN,
1696         EFFECT_TE_TEI_G3,
1697         EFFECT_TE_TEI_SMOKE,
1698         EFFECT_TE_TEI_BIGEXPLOSION,
1699         EFFECT_TE_TEI_PLASMAHIT,
1700         EFFECT_EF_STARDUST,
1701         EFFECT_TR_ROCKET,
1702         EFFECT_TR_GRENADE,
1703         EFFECT_TR_BLOOD,
1704         EFFECT_TR_WIZSPIKE,
1705         EFFECT_TR_SLIGHTBLOOD,
1706         EFFECT_TR_KNIGHTSPIKE,
1707         EFFECT_TR_VORESPIKE,
1708         EFFECT_TR_NEHAHRASMOKE,
1709         EFFECT_TR_NEXUIZPLASMA,
1710         EFFECT_TR_GLOWTRAIL,
1711         EFFECT_SVC_PARTICLE,
1712         EFFECT_TOTAL
1713 }
1714 effectnameindex_t;
1715
1716 int CL_ParticleEffectIndexForName(const char *name);
1717 const char *CL_ParticleEffectNameForIndex(int i);
1718 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);
1719 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);
1720 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);
1721 void CL_ParseParticleEffect (void);
1722 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);
1723 void CL_ParticleRain (const vec3_t mins, const vec3_t maxs, const vec3_t dir, int count, int colorbase, int type);
1724 void CL_EntityParticles (const entity_t *ent);
1725 void CL_ParticleExplosion (const vec3_t org);
1726 void CL_ParticleExplosion2 (const vec3_t org, int colorStart, int colorLength);
1727 void R_NewExplosion(const vec3_t org);
1728
1729 void Debug_PolygonBegin(const char *picname, int flags);
1730 void Debug_PolygonVertex(float x, float y, float z, float s, float t, float r, float g, float b, float a);
1731 void Debug_PolygonEnd(void);
1732
1733 #include "cl_screen.h"
1734
1735 extern qboolean sb_showscores;
1736
1737 float RSurf_FogVertex(const vec3_t p);
1738 float RSurf_FogPoint(const vec3_t p);
1739
1740 typedef enum r_viewport_type_e
1741 {
1742         R_VIEWPORTTYPE_ORTHO,
1743         R_VIEWPORTTYPE_PERSPECTIVE,
1744         R_VIEWPORTTYPE_PERSPECTIVE_INFINITEFARCLIP,
1745         R_VIEWPORTTYPE_PERSPECTIVECUBESIDE,
1746         R_VIEWPORTTYPE_TOTAL
1747 }
1748 r_viewport_type_t;
1749
1750 typedef struct r_viewport_s
1751 {
1752         matrix4x4_t cameramatrix; // from entity (transforms from camera entity to world)
1753         matrix4x4_t viewmatrix; // actual matrix for rendering (transforms to viewspace)
1754         matrix4x4_t projectmatrix; // actual projection matrix (transforms from viewspace to screen)
1755         int x;
1756         int y;
1757         int z;
1758         int width;
1759         int height;
1760         int depth;
1761         r_viewport_type_t type;
1762         float screentodepth[2]; // used by deferred renderer to calculate linear depth from device depth coordinates
1763 }
1764 r_viewport_t;
1765
1766 typedef struct r_refdef_view_s
1767 {
1768         // view information (changes multiple times per frame)
1769         // if any of these variables change then r_refdef.viewcache must be regenerated
1770         // by calling R_View_Update
1771         // (which also updates viewport, scissor, colormask)
1772
1773         // it is safe and expected to copy this into a structure on the stack and
1774         // call the renderer recursively, then restore from the stack afterward
1775         // (as long as R_View_Update is called)
1776
1777         // eye position information
1778         matrix4x4_t matrix, inverse_matrix;
1779         vec3_t origin;
1780         vec3_t forward;
1781         vec3_t left;
1782         vec3_t right;
1783         vec3_t up;
1784         int numfrustumplanes;
1785         mplane_t frustum[6];
1786         qboolean useclipplane;
1787         qboolean usecustompvs; // uses r_refdef.viewcache.pvsbits as-is rather than computing it
1788         mplane_t clipplane;
1789         float frustum_x, frustum_y;
1790         vec3_t frustumcorner[4];
1791         // if turned off it renders an ortho view
1792         int useperspective;
1793         float ortho_x, ortho_y;
1794
1795         // screen area to render in
1796         int x;
1797         int y;
1798         int z;
1799         int width;
1800         int height;
1801         int depth;
1802         r_viewport_t viewport; // note: if r_viewscale is used, the viewport.width and viewport.height may be less than width and height
1803
1804         // which color components to allow (for anaglyph glasses)
1805         int colormask[4];
1806
1807         // global RGB color multiplier for rendering
1808         float colorscale;
1809
1810         // whether to call R_ClearScreen before rendering stuff
1811         qboolean clear;
1812         // if true, don't clear or do any post process effects (bloom, etc)
1813         qboolean isoverlay;
1814         // 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)
1815         qboolean ismain;
1816
1817         // whether to draw r_showtris and such, this is only true for the main
1818         // view render, all secondary renders (mirrors, portals, cameras,
1819         // distortion effects, etc) omit such debugging information
1820         qboolean showdebug;
1821
1822         // these define which values to use in GL_CullFace calls to request frontface or backface culling
1823         int cullface_front;
1824         int cullface_back;
1825
1826         // render quality (0 to 1) - affects r_drawparticles_drawdistance and others
1827         float quality;
1828 }
1829 r_refdef_view_t;
1830
1831 typedef struct r_refdef_viewcache_s
1832 {
1833         // updated by gl_main_newmap()
1834         int maxentities;
1835         int world_numclusters;
1836         int world_numclusterbytes;
1837         int world_numleafs;
1838         int world_numsurfaces;
1839
1840         // these properties are generated by R_View_Update()
1841
1842         // which entities are currently visible for this viewpoint
1843         // (the used range is 0...r_refdef.scene.numentities)
1844         unsigned char *entityvisible;
1845
1846         // flag arrays used for visibility checking on world model
1847         // (all other entities have no per-surface/per-leaf visibility checks)
1848         unsigned char *world_pvsbits;
1849         unsigned char *world_leafvisible;
1850         unsigned char *world_surfacevisible;
1851         // if true, the view is currently in a leaf without pvs data
1852         qboolean world_novis;
1853 }
1854 r_refdef_viewcache_t;
1855
1856 // TODO: really think about which fields should go into scene and which one should stay in refdef [1/7/2008 Black]
1857 // maybe also refactor some of the functions to support different setting sources (ie. fogenabled, etc.) for different scenes
1858 typedef struct r_refdef_scene_s {
1859         // whether to call S_ExtraUpdate during render to reduce sound chop
1860         qboolean extraupdate;
1861
1862         // (client gameworld) time for rendering time based effects
1863         double time;
1864
1865         // the world
1866         entity_render_t *worldentity;
1867
1868         // same as worldentity->model
1869         dp_model_t *worldmodel;
1870
1871         // renderable entities (excluding world)
1872         entity_render_t **entities;
1873         int numentities;
1874         int maxentities;
1875
1876         // field of temporary entities that is reset each (client) frame
1877         entity_render_t *tempentities;
1878         int numtempentities;
1879         int maxtempentities;
1880         qboolean expandtempentities;
1881
1882         // renderable dynamic lights
1883         rtlight_t *lights[MAX_DLIGHTS];
1884         rtlight_t templights[MAX_DLIGHTS];
1885         int numlights;
1886
1887         // intensities for light styles right now, controls rtlights
1888         float rtlightstylevalue[MAX_LIGHTSTYLES];       // float fraction of base light value
1889         // 8.8bit fixed point intensities for light styles
1890         // controls intensity lightmap layers
1891         unsigned short lightstylevalue[MAX_LIGHTSTYLES];        // 8.8 fraction of base light value
1892
1893         float ambient;
1894
1895         qboolean rtworld;
1896         qboolean rtworldshadows;
1897         qboolean rtdlight;
1898         qboolean rtdlightshadows;
1899 } r_refdef_scene_t;
1900
1901 typedef struct r_refdef_s
1902 {
1903         // these fields define the basic rendering information for the world
1904         // but not the view, which could change multiple times in one rendered
1905         // frame (for example when rendering textures for certain effects)
1906
1907         // these are set for water warping before
1908         // frustum_x/frustum_y are calculated
1909         float frustumscale_x, frustumscale_y;
1910
1911         // current view settings (these get reset a few times during rendering because of water rendering, reflections, etc)
1912         r_refdef_view_t view;
1913         r_refdef_viewcache_t viewcache;
1914
1915         // minimum visible distance (pixels closer than this disappear)
1916         double nearclip;
1917         // maximum visible distance (pixels further than this disappear in 16bpp modes,
1918         // in 32bpp an infinite-farclip matrix is used instead)
1919         double farclip;
1920
1921         // fullscreen color blend
1922         float viewblend[4];
1923
1924         r_refdef_scene_t scene;
1925
1926         float fogplane[4];
1927         float fogplaneviewdist;
1928         qboolean fogplaneviewabove;
1929         float fogheightfade;
1930         float fogcolor[3];
1931         float fogrange;
1932         float fograngerecip;
1933         float fogmasktabledistmultiplier;
1934 #define FOGMASKTABLEWIDTH 1024
1935         float fogmasktable[FOGMASKTABLEWIDTH];
1936         float fogmasktable_start, fogmasktable_alpha, fogmasktable_range, fogmasktable_density;
1937         float fog_density;
1938         float fog_red;
1939         float fog_green;
1940         float fog_blue;
1941         float fog_alpha;
1942         float fog_start;
1943         float fog_end;
1944         float fog_height;
1945         float fog_fadedepth;
1946         qboolean fogenabled;
1947         qboolean oldgl_fogenable;
1948
1949         // new flexible texture height fog (overrides normal fog)
1950         char fog_height_texturename[64]; // note: must be 64 for the sscanf code
1951         unsigned char *fog_height_table1d;
1952         unsigned char *fog_height_table2d;
1953         int fog_height_tablesize; // enable
1954         float fog_height_tablescale;
1955         float fog_height_texcoordscale;
1956         char fogheighttexturename[64]; // detects changes to active fog height texture
1957
1958         int draw2dstage; // 0 = no, 1 = yes, other value = needs setting up again
1959
1960         // true during envmap command capture
1961         qboolean envmap;
1962
1963         // brightness of world lightmaps and related lighting
1964         // (often reduced when world rtlights are enabled)
1965         float lightmapintensity;
1966         // whether to draw world lights realtime, dlights realtime, and their shadows
1967         float polygonfactor;
1968         float polygonoffset;
1969         float shadowpolygonfactor;
1970         float shadowpolygonoffset;
1971
1972         // how long R_RenderView took on the previous frame
1973         double lastdrawscreentime;
1974
1975         // rendering stats for r_speeds display
1976         // (these are incremented in many places)
1977         int stats[r_stat_count];
1978 }
1979 r_refdef_t;
1980
1981 extern r_refdef_t r_refdef;
1982
1983 typedef enum waterlevel_e
1984 {
1985         WATERLEVEL_NONE,
1986         WATERLEVEL_WETFEET,
1987         WATERLEVEL_SWIMMING,
1988         WATERLEVEL_SUBMERGED
1989 }
1990 waterlevel_t;
1991
1992 typedef struct cl_clientmovement_state_s
1993 {
1994         // entity to be ignored for movement
1995         struct prvm_edict_s *self;
1996         // position
1997         vec3_t origin;
1998         vec3_t velocity;
1999         // current bounding box (different if crouched vs standing)
2000         vec3_t mins;
2001         vec3_t maxs;
2002         // currently on the ground
2003         qboolean onground;
2004         // currently crouching
2005         qboolean crouched;
2006         // what kind of water (SUPERCONTENTS_LAVA for instance)
2007         int watertype;
2008         // how deep
2009         waterlevel_t waterlevel;
2010         // weird hacks when jumping out of water
2011         // (this is in seconds and counts down to 0)
2012         float waterjumptime;
2013
2014         // user command
2015         usercmd_t cmd;
2016 }
2017 cl_clientmovement_state_t;
2018 void CL_ClientMovement_PlayerMove_Frame(cl_clientmovement_state_t *s);
2019
2020 // warpzone prediction hack (CSQC builtin)
2021 void CL_RotateMoves(const matrix4x4_t *m);
2022
2023 typedef enum meshname_e {
2024         MESH_DEBUG,
2025         MESH_CSQCPOLYGONS,
2026         MESH_PARTICLES,
2027         MESH_UI,
2028         NUM_MESHENTITIES,
2029 } meshname_t;
2030 extern entity_t cl_meshentities[NUM_MESHENTITIES];
2031 extern dp_model_t cl_meshentitymodels[NUM_MESHENTITIES];
2032 extern const char *cl_meshentitynames[NUM_MESHENTITIES];
2033 #define CL_Mesh_Debug() (&cl_meshentitymodels[MESH_DEBUG])
2034 #define CL_Mesh_CSQC() (&cl_meshentitymodels[MESH_CSQCPOLYGONS])
2035 #define CL_Mesh_Particles() (&cl_meshentitymodels[MESH_PARTICLES])
2036 #define CL_Mesh_UI() (&cl_meshentitymodels[MESH_UI])
2037 void CL_MeshEntities_AddToScene(void);
2038 void CL_MeshEntities_Reset(void);
2039
2040 void CL_NewFrameReceived(int num);
2041 void CL_ParseEntityLump(char *entitystring);
2042 void CL_FindNonSolidLocation(const vec3_t in, vec3_t out, vec_t radius);
2043 void CL_RelinkLightFlashes(void);
2044 void CL_Beam_AddPolygons(const beam_t *b);
2045 void Sbar_ShowFPS(void);
2046 void Sbar_ShowFPS_Update(void);
2047 void Host_SaveConfig(void);
2048 void Host_LoadConfig_f(void);
2049 void CL_UpdateMoveVars(void);
2050 void SCR_CaptureVideo_SoundFrame(const portable_sampleframe_t *paintbuffer, size_t length);
2051 void V_DriftPitch(void);
2052 void V_FadeViewFlashs(void);
2053 void V_CalcViewBlend(void);
2054 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);
2055 void V_CalcRefdef(void);
2056 void CL_Locs_Reload_f(void);
2057
2058 #endif
2059