improved shadowmap side culling
[xonotic/darkplaces.git] / 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 // LordHavoc: 256 dynamic lights
29 #define MAX_DLIGHTS 256
30
31 /// this is the maximum number of input packets that can be predicted
32 #define CL_MAX_USERCMDS 128
33
34 // flags for rtlight rendering
35 #define LIGHTFLAG_NORMALMODE 1
36 #define LIGHTFLAG_REALTIMEMODE 2
37
38 typedef struct effect_s
39 {
40         int active;
41         vec3_t origin;
42         double starttime;
43         float framerate;
44         int modelindex;
45         int startframe;
46         int endframe;
47         // these are for interpolation
48         int frame;
49         double frame1time;
50         double frame2time;
51 }
52 cl_effect_t;
53
54 typedef struct beam_s
55 {
56         int             entity;
57         // draw this as lightning polygons, or a model?
58         int             lightning;
59         struct model_s  *model;
60         float   endtime;
61         vec3_t  start, end;
62 }
63 beam_t;
64
65 typedef struct rtlight_s
66 {
67         // shadow volumes are done entirely in model space, so there are no matrices for dealing with them...  they just use the origin
68
69         // note that the world to light matrices are inversely scaled (divided) by lightradius
70
71         // core properties
72         /// matrix for transforming light filter coordinates to world coordinates
73         matrix4x4_t matrix_lighttoworld;
74         /// matrix for transforming world coordinates to light filter coordinates
75         matrix4x4_t matrix_worldtolight;
76         /// typically 1 1 1, can be lower (dim) or higher (overbright)
77         vec3_t color;
78         /// size of the light (remove?)
79         vec_t radius;
80         /// light filter
81         char cubemapname[64];
82         /// light style to monitor for brightness
83         int style;
84         /// whether light should render shadows
85         int shadow;
86         /// intensity of corona to render
87         vec_t corona;
88         /// radius scale of corona to render (1.0 means same as light radius)
89         vec_t coronasizescale;
90         /// ambient intensity to render
91         vec_t ambientscale;
92         /// diffuse intensity to render
93         vec_t diffusescale;
94         /// specular intensity to render
95         vec_t specularscale;
96         /// LIGHTFLAG_* flags
97         int flags;
98
99         // generated properties
100         /// used only for shadow volumes
101         vec3_t shadoworigin;
102         /// culling
103         vec3_t cullmins;
104         vec3_t cullmaxs;
105         // culling
106         //vec_t cullradius;
107         // squared cullradius
108         //vec_t cullradius2;
109
110         // rendering properties, updated each time a light is rendered
111         // this is rtlight->color * d_lightstylevalue
112         vec3_t currentcolor;
113         /// used by corona updates, due to occlusion query
114         float corona_visibility;
115         unsigned int corona_queryindex_visiblepixels;
116         unsigned int corona_queryindex_allpixels;
117         /// this is R_Shadow_Cubemap(rtlight->cubemapname)
118         rtexture_t *currentcubemap;
119
120         /// static light info
121         /// true if this light should be compiled as a static light
122         int isstatic;
123         /// true if this is a compiled world light, cleared if the light changes
124         int compiled;
125         /// the shadowing mode used to compile this light
126         int shadowmode;
127         /// premade shadow volumes to render for world entity
128         shadowmesh_t *static_meshchain_shadow_zpass;
129         shadowmesh_t *static_meshchain_shadow_zfail;
130         shadowmesh_t *static_meshchain_shadow_shadowmap;
131         /// used for visibility testing (more exact than bbox)
132         int static_numleafs;
133         int static_numleafpvsbytes;
134         int *static_leaflist;
135         unsigned char *static_leafpvs;
136         /// surfaces seen by light
137         int static_numsurfaces;
138         int *static_surfacelist;
139         /// flag bits indicating which triangles of the world model should cast
140         /// shadows, and which ones should be lit
141         ///
142         /// this avoids redundantly scanning the triangles in each surface twice
143         /// for whether they should cast shadows, once in culling and once in the
144         /// actual shadowmarklist production.
145         int static_numshadowtrispvsbytes;
146         unsigned char *static_shadowtrispvs;
147         /// this allows the lighting batch code to skip backfaces andother culled
148         /// triangles not relevant for lighting
149         /// (important on big surfaces such as terrain)
150         int static_numlighttrispvsbytes;
151         unsigned char *static_lighttrispvs;
152         /// masks of all shadowmap sides that have any potential static receivers or casters
153         int static_shadowmap_receivers;
154         int static_shadowmap_casters;
155 }
156 rtlight_t;
157
158 typedef struct dlight_s
159 {
160         // destroy light after this time
161         // (dlight only)
162         vec_t die;
163         // the entity that owns this light (can be NULL)
164         // (dlight only)
165         struct entity_render_s *ent;
166         // location
167         // (worldlight: saved to .rtlights file)
168         vec3_t origin;
169         // worldlight orientation
170         // (worldlight only)
171         // (worldlight: saved to .rtlights file)
172         vec3_t angles;
173         // dlight orientation/scaling/location
174         // (dlight only)
175         matrix4x4_t matrix;
176         // color of light
177         // (worldlight: saved to .rtlights file)
178         vec3_t color;
179         // cubemap name to use on this light
180         // (worldlight: saved to .rtlights file)
181         char cubemapname[64];
182         // make light flash while selected
183         // (worldlight only)
184         int selected;
185         // brightness (not really radius anymore)
186         // (worldlight: saved to .rtlights file)
187         vec_t radius;
188         // drop intensity this much each second
189         // (dlight only)
190         vec_t decay;
191         // intensity value which is dropped over time
192         // (dlight only)
193         vec_t intensity;
194         // initial values for intensity to modify
195         // (dlight only)
196         vec_t initialradius;
197         vec3_t initialcolor;
198         // light style which controls intensity of this light
199         // (worldlight: saved to .rtlights file)
200         int style;
201         // cast shadows
202         // (worldlight: saved to .rtlights file)
203         int shadow;
204         // corona intensity
205         // (worldlight: saved to .rtlights file)
206         vec_t corona;
207         // radius scale of corona to render (1.0 means same as light radius)
208         // (worldlight: saved to .rtlights file)
209         vec_t coronasizescale;
210         // ambient intensity to render
211         // (worldlight: saved to .rtlights file)
212         vec_t ambientscale;
213         // diffuse intensity to render
214         // (worldlight: saved to .rtlights file)
215         vec_t diffusescale;
216         // specular intensity to render
217         // (worldlight: saved to .rtlights file)
218         vec_t specularscale;
219         // LIGHTFLAG_* flags
220         // (worldlight: saved to .rtlights file)
221         int flags;
222         // linked list of world lights
223         // (worldlight only)
224         struct dlight_s *next;
225         // embedded rtlight struct for renderer
226         // (worldlight only)
227         rtlight_t rtlight;
228 }
229 dlight_t;
230
231 #define MAX_FRAMEGROUPBLENDS 4
232 typedef struct framegroupblend_s
233 {
234         // animation number and blend factor
235         // (for most models this is the frame number)
236         int frame;
237         float lerp;
238         // time frame began playing (for framegroup animations)
239         double start;
240 }
241 framegroupblend_t;
242
243 // this is derived from processing of the framegroupblend array
244 // note: technically each framegroupblend can produce two of these, but that
245 // never happens in practice because no one blends between more than 2
246 // framegroups at once
247 #define MAX_FRAMEBLENDS MAX_FRAMEGROUPBLENDS
248 typedef struct frameblend_s
249 {
250         int subframe;
251         float lerp;
252 }
253 frameblend_t;
254
255 // LordHavoc: this struct is intended for the renderer but some fields are
256 // used by the client.
257 //
258 // The renderer should not rely on any changes to this struct to be persistent
259 // across multiple frames because temp entities are wiped every frame, but it
260 // is acceptable to cache things in this struct that are not critical.
261 //
262 // For example the r_cullentities_trace code does such caching.
263 typedef struct entity_render_s
264 {
265         // location
266         //vec3_t origin;
267         // orientation
268         //vec3_t angles;
269         // transform matrix for model to world
270         matrix4x4_t matrix;
271         // transform matrix for world to model
272         matrix4x4_t inversematrix;
273         // opacity (alpha) of the model
274         float alpha;
275         // size the model is shown
276         float scale;
277         // transparent sorting offset
278         float transparent_offset;
279
280         // NULL = no model
281         dp_model_t *model;
282         // number of the entity represents, or 0 for non-network entities
283         int entitynumber;
284         // literal colormap colors for renderer, if both are 0 0 0 it is not colormapped
285         vec3_t colormap_pantscolor;
286         vec3_t colormap_shirtcolor;
287         // light, particles, etc
288         int effects;
289         // qw CTF flags and other internal-use-only effect bits
290         int internaleffects;
291         // for Alias models
292         int skinnum;
293         // render flags
294         int flags;
295
296         // colormod tinting of models
297         float colormod[3];
298         float glowmod[3];
299
300         // interpolated animation - active framegroups and blend factors
301         framegroupblend_t framegroupblend[MAX_FRAMEGROUPBLENDS];
302
303         // time of last model change (for shader animations)
304         double shadertime;
305
306         // calculated by the renderer (but not persistent)
307
308         // calculated during R_AddModelEntities
309         vec3_t mins, maxs;
310         // subframe numbers (-1 if not used) and their blending scalers (0-1), if interpolation is not desired, use subframeblend[0].subframe
311         frameblend_t frameblend[MAX_FRAMEBLENDS];
312
313         // animation cache index
314         int animcacheindex;
315
316         // current lighting from map (updated ONLY by client code, not renderer)
317         vec3_t modellight_ambient;
318         vec3_t modellight_diffuse; // q3bsp
319         vec3_t modellight_lightdir; // q3bsp
320
321         // FIELDS UPDATED BY RENDERER:
322         // last time visible during trace culling
323         double last_trace_visibility;
324 }
325 entity_render_t;
326
327 typedef struct entity_persistent_s
328 {
329         vec3_t trail_origin;
330
331         // particle trail
332         float trail_time;
333         qboolean trail_allowed; // set to false by teleports, true by update code, prevents bad lerps
334
335         // muzzleflash fading
336         float muzzleflash;
337
338         // interpolated movement
339
340         // start time of move
341         float lerpstarttime;
342         // time difference from start to end of move
343         float lerpdeltatime;
344         // the move itself, start and end
345         float oldorigin[3];
346         float oldangles[3];
347         float neworigin[3];
348         float newangles[3];
349 }
350 entity_persistent_t;
351
352 typedef struct entity_s
353 {
354         // baseline state (default values)
355         entity_state_t state_baseline;
356         // previous state (interpolating from this)
357         entity_state_t state_previous;
358         // current state (interpolating to this)
359         entity_state_t state_current;
360
361         // used for regenerating parts of render
362         entity_persistent_t persistent;
363
364         // the only data the renderer should know about
365         entity_render_t render;
366 }
367 entity_t;
368
369 typedef struct usercmd_s
370 {
371         vec3_t  viewangles;
372
373 // intended velocities
374         float   forwardmove;
375         float   sidemove;
376         float   upmove;
377
378         vec3_t  cursor_screen;
379         vec3_t  cursor_start;
380         vec3_t  cursor_end;
381         vec3_t  cursor_impact;
382         vec3_t  cursor_normal;
383         vec_t   cursor_fraction;
384         int             cursor_entitynumber;
385
386         double time; // time the move is executed for (cl_movement: clienttime, non-cl_movement: receivetime)
387         double receivetime; // time the move was received at
388         double clienttime; // time to which server state the move corresponds to
389         int msec; // for predicted moves
390         int buttons;
391         int impulse;
392         int sequence;
393         qboolean applied; // if false we're still accumulating a move
394         qboolean predicted; // if true the sequence should be sent as 0
395
396         // derived properties
397         double frametime;
398         qboolean canjump;
399         qboolean jump;
400         qboolean crouch;
401 } usercmd_t;
402
403 typedef struct lightstyle_s
404 {
405         int             length;
406         char    map[MAX_STYLESTRING];
407 } lightstyle_t;
408
409 typedef struct scoreboard_s
410 {
411         char    name[MAX_SCOREBOARDNAME];
412         int             frags;
413         int             colors; // two 4 bit fields
414         // QW fields:
415         int             qw_userid;
416         char    qw_userinfo[MAX_USERINFO_STRING];
417         float   qw_entertime;
418         int             qw_ping;
419         int             qw_packetloss;
420         int             qw_spectator;
421         char    qw_team[8];
422         char    qw_skin[MAX_QPATH];
423 } scoreboard_t;
424
425 typedef struct cshift_s
426 {
427         float   destcolor[3];
428         float   percent;                // 0-255
429         float   alphafade;      // (any speed)
430 } cshift_t;
431
432 #define CSHIFT_CONTENTS 0
433 #define CSHIFT_DAMAGE   1
434 #define CSHIFT_BONUS    2
435 #define CSHIFT_POWERUP  3
436 #define CSHIFT_VCSHIFT  4
437 #define NUM_CSHIFTS             5
438
439 #define NAME_LENGTH     64
440
441
442 //
443 // client_state_t should hold all pieces of the client state
444 //
445
446 #define SIGNONS         4                       // signon messages to receive before connected
447
448 #define MAX_DEMOS               8
449 #define MAX_DEMONAME    16
450
451 typedef enum cactive_e
452 {
453         ca_uninitialized,       // during early startup
454         ca_dedicated,           // a dedicated server with no ability to start a client
455         ca_disconnected,        // full screen console with no connection
456         ca_connected            // valid netcon, talking to a server
457 }
458 cactive_t;
459
460 typedef enum qw_downloadtype_e
461 {
462         dl_none,
463         dl_single,
464         dl_skin,
465         dl_model,
466         dl_sound
467 }
468 qw_downloadtype_t;
469
470 typedef enum capturevideoformat_e
471 {
472         CAPTUREVIDEOFORMAT_AVI_I420,
473         CAPTUREVIDEOFORMAT_OGG_VORBIS_THEORA,
474 }
475 capturevideoformat_t;
476
477 typedef struct capturevideostate_s
478 {
479         double startrealtime;
480         double framerate;
481         int framestep;
482         int framestepframe;
483         qboolean active;
484         qboolean realtime;
485         qboolean error;
486         int soundrate;
487         int soundchannels;
488         int frame;
489         double starttime;
490         double lastfpstime;
491         int lastfpsframe;
492         int soundsampleframe;
493         unsigned char *screenbuffer;
494         unsigned char *outbuffer;
495         char basename[MAX_QPATH];
496         int width, height;
497
498         // precomputed RGB to YUV tables
499         // converts the RGB values to YUV (see cap_avi.c for how to use them)
500         short rgbtoyuvscaletable[3][3][256];
501         unsigned char yuvnormalizetable[3][256];
502
503         // precomputed gamma ramp (only needed if the capturevideo module uses RGB output)
504         // 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
505         unsigned short vidramp[256 * 3];
506
507         // stuff to be filled in by the video format module
508         capturevideoformat_t format;
509         const char *formatextension;
510         qfile_t *videofile;
511                 // always use this:
512                 //   cls.capturevideo.videofile = FS_OpenRealFile(va("%s.%s", cls.capturevideo.basename, cls.capturevideo.formatextension), "wb", false);
513         void (*endvideo) (void);
514         void (*videoframes) (int num);
515         void (*soundframe) (const portable_sampleframe_t *paintbuffer, size_t length);
516
517         // format specific data
518         void *formatspecific;
519 }
520 capturevideostate_t;
521
522 #define CL_MAX_DOWNLOADACKS 4
523
524 typedef struct cl_downloadack_s
525 {
526         int start, size;
527 }
528 cl_downloadack_t;
529
530 typedef struct cl_soundstats_s
531 {
532         int mixedsounds;
533         int totalsounds;
534         int latency_milliseconds;
535 }
536 cl_soundstats_t;
537
538 //
539 // the client_static_t structure is persistent through an arbitrary number
540 // of server connections
541 //
542 typedef struct client_static_s
543 {
544         cactive_t state;
545
546         // all client memory allocations go in these pools
547         mempool_t *levelmempool;
548         mempool_t *permanentmempool;
549
550 // demo loop control
551         // -1 = don't play demos
552         int demonum;
553         // list of demos in loop
554         char demos[MAX_DEMOS][MAX_DEMONAME];
555         // the actively playing demo (set by CL_PlayDemo_f)
556         char demoname[MAX_QPATH];
557
558 // demo recording info must be here, because record is started before
559 // entering a map (and clearing client_state_t)
560         qboolean demorecording;
561         fs_offset_t demo_lastcsprogssize;
562         int demo_lastcsprogscrc;
563         qboolean demoplayback;
564         qboolean timedemo;
565         // -1 = use normal cd track
566         int forcetrack;
567         qfile_t *demofile;
568         // realtime at second frame of timedemo (LordHavoc: changed to double)
569         double td_starttime;
570         int td_frames; // total frames parsed
571         double td_onesecondnexttime;
572         double td_onesecondframes;
573         double td_onesecondrealtime;
574         double td_onesecondminfps;
575         double td_onesecondmaxfps;
576         double td_onesecondavgfps;
577         int td_onesecondavgcount;
578         // LordHavoc: pausedemo
579         qboolean demopaused;
580
581         // sound mixer statistics for showsound display
582         cl_soundstats_t soundstats;
583
584         qboolean connect_trying;
585         int connect_remainingtries;
586         double connect_nextsendtime;
587         lhnetsocket_t *connect_mysocket;
588         lhnetaddress_t connect_address;
589         // protocol version of the server we're connected to
590         // (kept outside client_state_t because it's used between levels)
591         protocolversion_t protocol;
592
593 #define MAX_RCONS 16
594         int rcon_trying;
595         lhnetaddress_t rcon_addresses[MAX_RCONS];
596         char rcon_commands[MAX_RCONS][MAX_INPUTLINE];
597         double rcon_timeout[MAX_RCONS];
598         int rcon_ringpos;
599
600 // connection information
601         // 0 to SIGNONS
602         int signon;
603         // network connection
604         netconn_t *netcon;
605
606         // download information
607         // (note: qw_download variables are also used)
608         cl_downloadack_t dp_downloadack[CL_MAX_DOWNLOADACKS];
609
610         // input sequence numbers are not reset on level change, only connect
611         int movesequence;
612         int servermovesequence;
613
614         // quakeworld stuff below
615
616         // value of "qport" cvar at time of connection
617         int qw_qport;
618         // copied from cls.netcon->qw. variables every time they change, or set by demos (which have no cls.netcon)
619         int qw_incoming_sequence;
620         int qw_outgoing_sequence;
621
622         // current file download buffer (only saved when file is completed)
623         char qw_downloadname[MAX_QPATH];
624         unsigned char *qw_downloadmemory;
625         int qw_downloadmemorycursize;
626         int qw_downloadmemorymaxsize;
627         int qw_downloadnumber;
628         int qw_downloadpercent;
629         qw_downloadtype_t qw_downloadtype;
630         // transfer rate display
631         double qw_downloadspeedtime;
632         int qw_downloadspeedcount;
633         int qw_downloadspeedrate;
634         qboolean qw_download_deflate;
635
636         // current file upload buffer (for uploading screenshots to server)
637         unsigned char *qw_uploaddata;
638         int qw_uploadsize;
639         int qw_uploadpos;
640
641         // user infostring
642         // this normally contains the following keys in quakeworld:
643         // password spectator name team skin topcolor bottomcolor rate noaim msg *ver *ip
644         char userinfo[MAX_USERINFO_STRING];
645
646         // video capture stuff
647         capturevideostate_t capturevideo;
648 }
649 client_static_t;
650
651 extern client_static_t  cls;
652
653 typedef struct client_movementqueue_s
654 {
655         double time;
656         float frametime;
657         int sequence;
658         float viewangles[3];
659         float move[3];
660         qboolean jump;
661         qboolean crouch;
662         qboolean canjump;
663 }
664 client_movementqueue_t;
665
666 //[515]: csqc
667 typedef struct
668 {
669         qboolean drawworld;
670         qboolean drawenginesbar;
671         qboolean drawcrosshair;
672 }csqc_vidvars_t;
673
674 typedef enum
675 {
676         PARTICLE_BILLBOARD = 0,
677         PARTICLE_SPARK = 1,
678         PARTICLE_ORIENTED_DOUBLESIDED = 2,
679         PARTICLE_VBEAM = 3,
680         PARTICLE_HBEAM = 4,
681         PARTICLE_INVALID = -1
682 }
683 porientation_t;
684
685 typedef enum
686 {
687         PBLEND_ALPHA = 0,
688         PBLEND_ADD = 1,
689         PBLEND_INVMOD = 2,
690         PBLEND_INVALID = -1
691 }
692 pblend_t;
693
694 typedef struct particletype_s
695 {
696         pblend_t blendmode;
697         porientation_t orientation;
698         qboolean lighting;
699 }
700 particletype_t;
701
702 typedef enum
703 {
704         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
705 }
706 ptype_t;
707
708 typedef struct decal_s
709 {
710         // fields used by rendering:  (44 bytes)
711         unsigned short  typeindex;
712         unsigned short  texnum;
713         vec3_t                  org;
714         vec3_t                  normal;
715         float                   size;
716         float                   alpha; // 0-255
717         unsigned char   color[3];
718         unsigned char   unused1;
719         int                             clusterindex; // cheap culling by pvs
720
721         // fields not used by rendering: (36 bytes in 32bit, 40 bytes in 64bit)
722         float                   time2; // used for decal fade
723         unsigned int    owner; // decal stuck to this entity
724         dp_model_t                      *ownermodel; // model the decal is stuck to (used to make sure the entity is still alive)
725         vec3_t                  relativeorigin; // decal at this location in entity's coordinate space
726         vec3_t                  relativenormal; // decal oriented this way relative to entity's coordinate space
727 }
728 decal_t;
729
730 typedef struct particle_s
731 {
732         // fields used by rendering: (40 bytes)
733         unsigned char   typeindex;
734         pblend_t   blendmode;
735         porientation_t   orientation;
736         unsigned char   texnum;
737         vec3_t                  org;
738         vec3_t                  vel; // velocity of particle, or orientation of decal, or end point of beam
739         float                   size;
740         float                   alpha; // 0-255
741         unsigned char   color[3];
742         unsigned char   qualityreduction; // enables skipping of this particle according to r_refdef.view.qualityreduction
743         float           stretch; // only for sparks
744         int             staincolor;
745         signed char     staintexnum;
746         float           stainsizefactor;
747
748         // fields not used by rendering:  (40 bytes)
749         float                   sizeincrease; // rate of size change per second
750         float                   alphafade; // how much alpha reduces per second
751         float                   time2; // used for snow fluttering and decal fade
752         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)
753         float                   gravity; // how much gravity affects this particle (1.0 = normal gravity, 0.0 = none)
754         float                   airfriction; // how much air friction affects this object (objects with a low mass/size ratio tend to get more air friction)
755         float                   liquidfriction; // how much liquid friction affects this object (objects with a low mass/size ratio tend to get more liquid friction)
756         float                   delayedcollisions; // time that p->bounce becomes active
757         float                   delayedspawn; // time that particle appears and begins moving
758         float                   die; // time when this particle should be removed, regardless of alpha
759 }
760 particle_t;
761
762 typedef enum cl_parsingtextmode_e
763 {
764         CL_PARSETEXTMODE_NONE,
765         CL_PARSETEXTMODE_PING,
766         CL_PARSETEXTMODE_STATUS,
767         CL_PARSETEXTMODE_STATUS_PLAYERID,
768         CL_PARSETEXTMODE_STATUS_PLAYERIP
769 }
770 cl_parsingtextmode_t;
771
772 typedef struct cl_locnode_s
773 {
774         struct cl_locnode_s *next;
775         char *name;
776         vec3_t mins, maxs;
777 }
778 cl_locnode_t;
779
780 typedef struct showlmp_s
781 {
782         qboolean        isactive;
783         float           x;
784         float           y;
785         char            label[32];
786         char            pic[128];
787 }
788 showlmp_t;
789
790 //
791 // the client_state_t structure is wiped completely at every
792 // server signon
793 //
794 typedef struct client_state_s
795 {
796         // true if playing in a local game and no one else is connected
797         int islocalgame;
798
799         // send a clc_nop periodically until connected
800         float sendnoptime;
801
802         // current input being accumulated by mouse/joystick/etc input
803         usercmd_t cmd;
804         // latest moves sent to the server that have not been confirmed yet
805         usercmd_t movecmd[CL_MAX_USERCMDS];
806
807 // information for local display
808         // health, etc
809         int stats[MAX_CL_STATS];
810         float *statsf; // points to stats[] array
811         // last known inventory bit flags, for blinking
812         int olditems;
813         // cl.time of acquiring item, for blinking
814         float item_gettime[32];
815         // last known STAT_ACTIVEWEAPON
816         int activeweapon;
817         // cl.time of changing STAT_ACTIVEWEAPON
818         float weapontime;
819         // use pain anim frame if cl.time < this
820         float faceanimtime;
821         // for stair smoothing
822         float stairsmoothz;
823         double stairsmoothtime;
824
825         // color shifts for damage, powerups
826         cshift_t cshifts[NUM_CSHIFTS];
827         // and content types
828         cshift_t prev_cshifts[NUM_CSHIFTS];
829
830 // the client maintains its own idea of view angles, which are
831 // sent to the server each frame.  The server sets punchangle when
832 // the view is temporarily offset, and an angle reset commands at the start
833 // of each level and after teleporting.
834
835         // mviewangles is read from demo
836         // viewangles is either client controlled or lerped from mviewangles
837         vec3_t mviewangles[2], viewangles;
838         // update by server, used by qc to do weapon recoil
839         vec3_t mpunchangle[2], punchangle;
840         // update by server, can be used by mods to kick view around
841         vec3_t mpunchvector[2], punchvector;
842         // update by server, used for lean+bob (0 is newest)
843         vec3_t mvelocity[2], velocity;
844         // update by server, can be used by mods for zooming
845         vec_t mviewzoom[2], viewzoom;
846         // if true interpolation the mviewangles and other interpolation of the
847         // player is disabled until the next network packet
848         // this is used primarily by teleporters, and when spectating players
849         // special checking of the old fixangle[1] is used to differentiate
850         // between teleporting and spectating
851         qboolean fixangle[2];
852
853         // client movement simulation
854         // these fields are only updated by CL_ClientMovement (called by CL_SendMove after parsing each network packet)
855         // set by CL_ClientMovement_Replay functions
856         qboolean movement_predicted;
857         // if true the CL_ClientMovement_Replay function will update origin, etc
858         qboolean movement_replay;
859         // simulated data (this is valid even if cl.movement is false)
860         vec3_t movement_origin;
861         vec3_t movement_velocity;
862         // whether the replay should allow a jump at the first sequence
863         qboolean movement_replay_canjump;
864
865 // pitch drifting vars
866         float idealpitch;
867         float pitchvel;
868         qboolean nodrift;
869         float driftmove;
870         double laststop;
871
872 //[515]: added for csqc purposes
873         float sensitivityscale;
874         csqc_vidvars_t csqc_vidvars;    //[515]: these parms must be set to true by default
875         qboolean csqc_wantsmousemove;
876         struct model_s *csqc_model_precache[MAX_MODELS];
877
878         // local amount for smoothing stepups
879         //float crouch;
880
881         // sent by server
882         qboolean paused;
883         qboolean onground;
884         qboolean inwater;
885
886         // used by bob
887         qboolean oldonground;
888         double lastongroundtime;
889         double hitgroundtime;
890
891         // don't change view angle, full screen, etc
892         int intermission;
893         // latched at intermission start
894         double completed_time;
895
896         // the timestamp of the last two messages
897         double mtime[2];
898
899         // clients view of time, time should be between mtime[0] and mtime[1] to
900         // generate a lerp point for other data, oldtime is the previous frame's
901         // value of time, frametime is the difference between time and oldtime
902         // note: cl.time may be beyond cl.mtime[0] if packet loss is occuring, it
903         // is only forcefully limited when a packet is received
904         double time, oldtime;
905         // how long it has been since the previous client frame in real time
906         // (not game time, for that use cl.time - cl.oldtime)
907         double realframetime;
908         
909         // fade var for fading while dead
910         float deathfade;
911
912         // motionblur alpha level variable
913         float motionbluralpha;
914
915         // copy of realtime from last recieved message, for net trouble icon
916         float last_received_message;
917
918 // information that is static for the entire time connected to a server
919         struct model_s *model_precache[MAX_MODELS];
920         struct sfx_s *sound_precache[MAX_SOUNDS];
921
922         // FIXME: this is a lot of memory to be keeping around, this really should be dynamically allocated and freed somehow
923         char model_name[MAX_MODELS][MAX_QPATH];
924         char sound_name[MAX_SOUNDS][MAX_QPATH];
925
926         // for display on solo scoreboard
927         char levelname[40];
928         // cl_entitites[cl.viewentity] = player
929         int viewentity;
930         // the real player entity (normally same as viewentity,
931         // different than viewentity if mod uses chasecam or other tricks)
932         int realplayerentity;
933         // this is updated to match cl.viewentity whenever it is in the clients
934         // range, basically this is used in preference to cl.realplayerentity for
935         // most purposes because when spectating another player it should show
936         // their information rather than yours
937         int playerentity;
938         // max players that can be in this game
939         int maxclients;
940         // type of game (deathmatch, coop, singleplayer)
941         int gametype;
942
943         // models and sounds used by engine code (particularly cl_parse.c)
944         dp_model_t *model_bolt;
945         dp_model_t *model_bolt2;
946         dp_model_t *model_bolt3;
947         dp_model_t *model_beam;
948         sfx_t *sfx_wizhit;
949         sfx_t *sfx_knighthit;
950         sfx_t *sfx_tink1;
951         sfx_t *sfx_ric1;
952         sfx_t *sfx_ric2;
953         sfx_t *sfx_ric3;
954         sfx_t *sfx_r_exp3;
955         // indicates that the file "sound/misc/talk2.wav" was found (for use by team chat messages)
956         qboolean foundtalk2wav;
957
958 // refresh related state
959
960         // cl_entitites[0].model
961         struct model_s *worldmodel;
962
963         // the gun model
964         entity_t viewent;
965
966         // cd audio
967         int cdtrack, looptrack;
968
969 // frag scoreboard
970
971         // [cl.maxclients]
972         scoreboard_t *scores;
973
974         // keep track of svc_print parsing state (analyzes ping reports and status reports)
975         cl_parsingtextmode_t parsingtextmode;
976         int parsingtextplayerindex;
977         // set by scoreboard code when sending ping command, this causes the next ping results to be hidden
978         // (which could eat the wrong ping report if the player issues one
979         //  manually, but they would still see a ping report, just a later one
980         //  caused by the scoreboard code rather than the one they intentionally
981         //  issued)
982         int parsingtextexpectingpingforscores;
983
984         // entity database stuff
985         // latest received entity frame numbers
986 #define LATESTFRAMENUMS 3
987         int latestframenums[LATESTFRAMENUMS];
988         entityframe_database_t *entitydatabase;
989         entityframe4_database_t *entitydatabase4;
990         entityframeqw_database_t *entitydatabaseqw;
991
992         // keep track of quake entities because they need to be killed if they get stale
993         int lastquakeentity;
994         unsigned char isquakeentity[MAX_EDICTS];
995
996         // bounding boxes for clientside movement
997         vec3_t playerstandmins;
998         vec3_t playerstandmaxs;
999         vec3_t playercrouchmins;
1000         vec3_t playercrouchmaxs;
1001
1002         int max_entities;
1003         int max_static_entities;
1004         int max_effects;
1005         int max_beams;
1006         int max_dlights;
1007         int max_lightstyle;
1008         int max_brushmodel_entities;
1009         int max_particles;
1010         int max_decals;
1011         int max_showlmps;
1012
1013         entity_t *entities;
1014         unsigned char *entities_active;
1015         entity_t *static_entities;
1016         cl_effect_t *effects;
1017         beam_t *beams;
1018         dlight_t *dlights;
1019         lightstyle_t *lightstyle;
1020         int *brushmodel_entities;
1021         particle_t *particles;
1022         decal_t *decals;
1023         showlmp_t *showlmps;
1024
1025         int num_entities;
1026         int num_static_entities;
1027         int num_brushmodel_entities;
1028         int num_effects;
1029         int num_beams;
1030         int num_dlights;
1031         int num_particles;
1032         int num_decals;
1033         int num_showlmps;
1034
1035         double particles_updatetime;
1036         double decals_updatetime;
1037         int free_particle;
1038         int free_decal;
1039
1040         // cl_serverextension_download feature
1041         int loadmodel_current;
1042         int downloadmodel_current;
1043         int loadmodel_total;
1044         int loadsound_current;
1045         int downloadsound_current;
1046         int loadsound_total;
1047         qboolean downloadcsqc;
1048         qboolean loadcsqc;
1049         qboolean loadbegun;
1050         qboolean loadfinished;
1051
1052         // quakeworld stuff
1053
1054         // local copy of the server infostring
1055         char qw_serverinfo[MAX_SERVERINFO_STRING];
1056
1057         // time of last qw "pings" command sent to server while showing scores
1058         double last_ping_request;
1059
1060         // used during connect
1061         int qw_servercount;
1062
1063         // updated from serverinfo
1064         int qw_teamplay;
1065
1066         // unused: indicates whether the player is spectating
1067         // use cl.scores[cl.playerentity-1].qw_spectator instead
1068         //qboolean qw_spectator;
1069
1070         // last time an input packet was sent
1071         double lastpackettime;
1072
1073         // movement parameters for client prediction
1074         unsigned int moveflags;
1075         float movevars_wallfriction;
1076         float movevars_waterfriction;
1077         float movevars_friction;
1078         float movevars_timescale;
1079         float movevars_gravity;
1080         float movevars_stopspeed;
1081         float movevars_maxspeed;
1082         float movevars_spectatormaxspeed;
1083         float movevars_accelerate;
1084         float movevars_airaccelerate;
1085         float movevars_wateraccelerate;
1086         float movevars_entgravity;
1087         float movevars_jumpvelocity;
1088         float movevars_edgefriction;
1089         float movevars_maxairspeed;
1090         float movevars_stepheight;
1091         float movevars_airaccel_qw;
1092         float movevars_airaccel_sideways_friction;
1093         float movevars_airstopaccelerate;
1094         float movevars_airstrafeaccelerate;
1095         float movevars_maxairstrafespeed;
1096         float movevars_aircontrol;
1097         float movevars_warsowbunny_airforwardaccel;
1098         float movevars_warsowbunny_accel;
1099         float movevars_warsowbunny_topspeed;
1100         float movevars_warsowbunny_turnaccel;
1101         float movevars_warsowbunny_backtosideratio;
1102         float movevars_ticrate;
1103
1104         // models used by qw protocol
1105         int qw_modelindex_spike;
1106         int qw_modelindex_player;
1107         int qw_modelindex_flag;
1108         int qw_modelindex_s_explod;
1109
1110         vec3_t qw_intermission_origin;
1111         vec3_t qw_intermission_angles;
1112
1113         // 255 is the most nails the QW protocol could send
1114         int qw_num_nails;
1115         vec_t qw_nails[255][6];
1116
1117         float qw_weaponkick;
1118
1119         int qw_validsequence;
1120
1121         int qw_deltasequence[QW_UPDATE_BACKUP];
1122
1123         // csqc stuff:
1124         // server entity number corresponding to a clientside entity
1125         unsigned short csqc_server2csqcentitynumber[MAX_EDICTS];
1126         qboolean csqc_loaded;
1127         vec3_t csqc_origin;
1128         vec3_t csqc_angles;
1129         qboolean csqc_usecsqclistener;
1130         matrix4x4_t csqc_listenermatrix;
1131         char csqc_printtextbuf[MAX_INPUTLINE];
1132
1133         // collision culling data
1134         world_t world;
1135
1136         // loc file stuff (points and boxes describing locations in the level)
1137         cl_locnode_t *locnodes;
1138         // this is updated to cl.movement_origin whenever health is < 1
1139         // used by %d print in say/say_team messages if cl_locs_enable is on
1140         vec3_t lastdeathorigin;
1141
1142         // processing buffer used by R_BuildLightMap, reallocated as needed,
1143         // freed on each level change
1144         size_t buildlightmapmemorysize;
1145         unsigned char *buildlightmapmemory;
1146 }
1147 client_state_t;
1148
1149 //
1150 // cvars
1151 //
1152 extern cvar_t cl_name;
1153 extern cvar_t cl_color;
1154 extern cvar_t cl_rate;
1155 extern cvar_t cl_pmodel;
1156 extern cvar_t cl_playermodel;
1157 extern cvar_t cl_playerskin;
1158
1159 extern cvar_t rcon_password;
1160 extern cvar_t rcon_address;
1161
1162 extern cvar_t cl_upspeed;
1163 extern cvar_t cl_forwardspeed;
1164 extern cvar_t cl_backspeed;
1165 extern cvar_t cl_sidespeed;
1166
1167 extern cvar_t cl_movespeedkey;
1168
1169 extern cvar_t cl_yawspeed;
1170 extern cvar_t cl_pitchspeed;
1171
1172 extern cvar_t cl_anglespeedkey;
1173
1174 extern cvar_t cl_autofire;
1175
1176 extern cvar_t cl_shownet;
1177 extern cvar_t cl_nolerp;
1178 extern cvar_t cl_nettimesyncfactor;
1179 extern cvar_t cl_nettimesyncboundmode;
1180 extern cvar_t cl_nettimesyncboundtolerance;
1181
1182 extern cvar_t cl_pitchdriftspeed;
1183 extern cvar_t lookspring;
1184 extern cvar_t lookstrafe;
1185 extern cvar_t sensitivity;
1186
1187 extern cvar_t freelook;
1188
1189 extern cvar_t m_pitch;
1190 extern cvar_t m_yaw;
1191 extern cvar_t m_forward;
1192 extern cvar_t m_side;
1193
1194 extern cvar_t cl_autodemo;
1195 extern cvar_t cl_autodemo_nameformat;
1196
1197 extern cvar_t r_draweffects;
1198
1199 extern cvar_t cl_explosions_alpha_start;
1200 extern cvar_t cl_explosions_alpha_end;
1201 extern cvar_t cl_explosions_size_start;
1202 extern cvar_t cl_explosions_size_end;
1203 extern cvar_t cl_explosions_lifetime;
1204 extern cvar_t cl_stainmaps;
1205 extern cvar_t cl_stainmaps_clearonload;
1206
1207 extern cvar_t cl_prydoncursor;
1208
1209 extern cvar_t cl_locs_enable;
1210
1211 extern client_state_t cl;
1212
1213 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);
1214
1215 cl_locnode_t *CL_Locs_FindNearest(const vec3_t point);
1216 void CL_Locs_FindLocationName(char *buffer, size_t buffersize, vec3_t point);
1217
1218 //=============================================================================
1219
1220 //
1221 // cl_main
1222 //
1223
1224 void CL_Shutdown (void);
1225 void CL_Init (void);
1226
1227 void CL_EstablishConnection(const char *host);
1228
1229 void CL_Disconnect (void);
1230 void CL_Disconnect_f (void);
1231
1232 void CL_UpdateRenderEntity(entity_render_t *ent);
1233 void CL_SetEntityColormapColors(entity_render_t *ent, int colormap);
1234 void CL_UpdateViewEntities(void);
1235
1236 //
1237 // cl_input
1238 //
1239 typedef struct kbutton_s
1240 {
1241         int             down[2];                // key nums holding it down
1242         int             state;                  // low bit is down state
1243 }
1244 kbutton_t;
1245
1246 extern  kbutton_t       in_mlook, in_klook;
1247 extern  kbutton_t       in_strafe;
1248 extern  kbutton_t       in_speed;
1249
1250 void CL_InitInput (void);
1251 void CL_SendMove (void);
1252
1253 void CL_ValidateState(entity_state_t *s);
1254 void CL_MoveLerpEntityStates(entity_t *ent);
1255 void CL_LerpUpdate(entity_t *e);
1256 void CL_ParseTEnt (void);
1257 void CL_NewBeam (int ent, vec3_t start, vec3_t end, dp_model_t *m, int lightning);
1258 void CL_RelinkBeams (void);
1259 void CL_Beam_CalculatePositions (const beam_t *b, vec3_t start, vec3_t end);
1260 void CL_ClientMovement_Replay(void);
1261
1262 void CL_ClearTempEntities (void);
1263 entity_render_t *CL_NewTempEntity (double shadertime);
1264
1265 void CL_Effect(vec3_t org, int modelindex, int startframe, int framecount, float framerate);
1266
1267 void CL_ClearState (void);
1268 void CL_ExpandEntities(int num);
1269 void CL_SetInfo(const char *key, const char *value, qboolean send, qboolean allowstarkey, qboolean allowmodel, qboolean quiet);
1270
1271
1272 void CL_UpdateWorld (void);
1273 void CL_WriteToServer (void);
1274 void CL_Input (void);
1275 extern int cl_ignoremousemoves;
1276
1277
1278 float CL_KeyState (kbutton_t *key);
1279 const char *Key_KeynumToString (int keynum);
1280 int Key_StringToKeynum (const char *str);
1281
1282 //
1283 // cl_demo.c
1284 //
1285 void CL_StopPlayback(void);
1286 void CL_ReadDemoMessage(void);
1287 void CL_WriteDemoMessage(sizebuf_t *mesage);
1288
1289 void CL_CutDemo(unsigned char **buf, fs_offset_t *filesize);
1290 void CL_PasteDemo(unsigned char **buf, fs_offset_t *filesize);
1291
1292 void CL_NextDemo(void);
1293 void CL_Stop_f(void);
1294 void CL_Record_f(void);
1295 void CL_PlayDemo_f(void);
1296 void CL_TimeDemo_f(void);
1297
1298 //
1299 // cl_parse.c
1300 //
1301 void CL_Parse_Init(void);
1302 void CL_Parse_Shutdown(void);
1303 void CL_ParseServerMessage(void);
1304 void CL_Parse_DumpPacket(void);
1305 void CL_Parse_ErrorCleanUp(void);
1306 void QW_CL_StartUpload(unsigned char *data, int size);
1307 extern cvar_t qport;
1308 void CL_KeepaliveMessage(qboolean readmessages); // call this during loading of large content
1309
1310 //
1311 // view
1312 //
1313 void V_StartPitchDrift (void);
1314 void V_StopPitchDrift (void);
1315
1316 void V_Init (void);
1317 float V_CalcRoll (vec3_t angles, vec3_t velocity);
1318 void V_UpdateBlends (void);
1319 void V_ParseDamage (void);
1320
1321 //
1322 // cl_part
1323 //
1324
1325 extern cvar_t cl_particles;
1326 extern cvar_t cl_particles_quality;
1327 extern cvar_t cl_particles_size;
1328 extern cvar_t cl_particles_quake;
1329 extern cvar_t cl_particles_blood;
1330 extern cvar_t cl_particles_blood_alpha;
1331 extern cvar_t cl_particles_blood_bloodhack;
1332 extern cvar_t cl_particles_bulletimpacts;
1333 extern cvar_t cl_particles_explosions_sparks;
1334 extern cvar_t cl_particles_explosions_shell;
1335 extern cvar_t cl_particles_rain;
1336 extern cvar_t cl_particles_snow;
1337 extern cvar_t cl_particles_smoke;
1338 extern cvar_t cl_particles_smoke_alpha;
1339 extern cvar_t cl_particles_smoke_alphafade;
1340 extern cvar_t cl_particles_sparks;
1341 extern cvar_t cl_particles_bubbles;
1342 extern cvar_t cl_decals;
1343 extern cvar_t cl_decals_time;
1344 extern cvar_t cl_decals_fadetime;
1345
1346 void CL_Particles_Clear(void);
1347 void CL_Particles_Init(void);
1348 void CL_Particles_Shutdown(void);
1349 particle_t *CL_NewParticle(unsigned short ptypeindex, int pcolor1, int pcolor2, int ptex, float psize, float psizeincrease, float palpha, float palphafade, float pgravity, float pbounce, float px, float py, float pz, float pvx, float pvy, float pvz, float pairfriction, float pliquidfriction, float originjitter, float velocityjitter, qboolean pqualityreduction, float lifetime, float stretch, pblend_t blendmode, porientation_t orientation, int staincolor1, int staincolor2, int staintex);
1350
1351 typedef enum effectnameindex_s
1352 {
1353         EFFECT_NONE,
1354         EFFECT_TE_GUNSHOT,
1355         EFFECT_TE_GUNSHOTQUAD,
1356         EFFECT_TE_SPIKE,
1357         EFFECT_TE_SPIKEQUAD,
1358         EFFECT_TE_SUPERSPIKE,
1359         EFFECT_TE_SUPERSPIKEQUAD,
1360         EFFECT_TE_WIZSPIKE,
1361         EFFECT_TE_KNIGHTSPIKE,
1362         EFFECT_TE_EXPLOSION,
1363         EFFECT_TE_EXPLOSIONQUAD,
1364         EFFECT_TE_TAREXPLOSION,
1365         EFFECT_TE_TELEPORT,
1366         EFFECT_TE_LAVASPLASH,
1367         EFFECT_TE_SMALLFLASH,
1368         EFFECT_TE_FLAMEJET,
1369         EFFECT_EF_FLAME,
1370         EFFECT_TE_BLOOD,
1371         EFFECT_TE_SPARK,
1372         EFFECT_TE_PLASMABURN,
1373         EFFECT_TE_TEI_G3,
1374         EFFECT_TE_TEI_SMOKE,
1375         EFFECT_TE_TEI_BIGEXPLOSION,
1376         EFFECT_TE_TEI_PLASMAHIT,
1377         EFFECT_EF_STARDUST,
1378         EFFECT_TR_ROCKET,
1379         EFFECT_TR_GRENADE,
1380         EFFECT_TR_BLOOD,
1381         EFFECT_TR_WIZSPIKE,
1382         EFFECT_TR_SLIGHTBLOOD,
1383         EFFECT_TR_KNIGHTSPIKE,
1384         EFFECT_TR_VORESPIKE,
1385         EFFECT_TR_NEHAHRASMOKE,
1386         EFFECT_TR_NEXUIZPLASMA,
1387         EFFECT_TR_GLOWTRAIL,
1388         EFFECT_SVC_PARTICLE,
1389         EFFECT_TOTAL
1390 }
1391 effectnameindex_t;
1392
1393 int CL_ParticleEffectIndexForName(const char *name);
1394 const char *CL_ParticleEffectNameForIndex(int i);
1395 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);
1396 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);
1397 void CL_ParseParticleEffect (void);
1398 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);
1399 void CL_ParticleRain (const vec3_t mins, const vec3_t maxs, const vec3_t dir, int count, int colorbase, int type);
1400 void CL_EntityParticles (const entity_t *ent);
1401 void CL_ParticleExplosion (const vec3_t org);
1402 void CL_ParticleExplosion2 (const vec3_t org, int colorStart, int colorLength);
1403 void R_NewExplosion(const vec3_t org);
1404
1405 void Debug_PolygonBegin(const char *picname, int flags);
1406 void Debug_PolygonVertex(float x, float y, float z, float s, float t, float r, float g, float b, float a);
1407 void Debug_PolygonEnd(void);
1408
1409 #include "cl_screen.h"
1410
1411 extern qboolean sb_showscores;
1412
1413 float FogPoint_World(const vec3_t p);
1414 float FogPoint_Model(const vec3_t p);
1415 float FogForDistance(vec_t dist);
1416
1417 typedef struct r_refdef_stats_s
1418 {
1419         int renders;
1420         int entities;
1421         int entities_surfaces;
1422         int entities_triangles;
1423         int world_leafs;
1424         int world_portals;
1425         int world_surfaces;
1426         int world_triangles;
1427         int lightmapupdates;
1428         int lightmapupdatepixels;
1429         int particles;
1430         int decals;
1431         int meshes;
1432         int meshes_elements;
1433         int lights;
1434         int lights_clears;
1435         int lights_scissored;
1436         int lights_lighttriangles;
1437         int lights_shadowtriangles;
1438         int lights_dynamicshadowtriangles;
1439         int bloom;
1440         int bloom_copypixels;
1441         int bloom_drawpixels;
1442 }
1443 r_refdef_stats_t;
1444
1445 typedef enum r_viewport_type_e
1446 {
1447         R_VIEWPORTTYPE_ORTHO,
1448         R_VIEWPORTTYPE_PERSPECTIVE,
1449         R_VIEWPORTTYPE_PERSPECTIVE_INFINITEFARCLIP,
1450         R_VIEWPORTTYPE_PERSPECTIVECUBESIDE,
1451         R_VIEWPORTTYPE_TOTAL
1452 }
1453 r_viewport_type_t;
1454
1455 typedef struct r_viewport_s
1456 {
1457         double m[16];
1458         matrix4x4_t cameramatrix; // from entity (transforms from camera entity to world)
1459         matrix4x4_t viewmatrix; // actual matrix for rendering (transforms to viewspace)
1460         matrix4x4_t projectmatrix; // actual projection matrix (transforms from viewspace to screen)
1461         int x;
1462         int y;
1463         int z;
1464         int width;
1465         int height;
1466         int depth;
1467         r_viewport_type_t type;
1468 }
1469 r_viewport_t;
1470
1471 typedef struct r_refdef_view_s
1472 {
1473         // view information (changes multiple times per frame)
1474         // if any of these variables change then r_refdef.viewcache must be regenerated
1475         // by calling R_View_Update
1476         // (which also updates viewport, scissor, colormask)
1477
1478         // it is safe and expected to copy this into a structure on the stack and
1479         // call the renderer recursively, then restore from the stack afterward
1480         // (as long as R_View_Update is called)
1481
1482         // eye position information
1483         matrix4x4_t matrix, inverse_matrix;
1484         vec3_t origin;
1485         vec3_t forward;
1486         vec3_t left;
1487         vec3_t right;
1488         vec3_t up;
1489         int numfrustumplanes;
1490         mplane_t frustum[6];
1491         qboolean useclipplane;
1492         qboolean usecustompvs; // uses r_refdef.viewcache.pvsbits as-is rather than computing it
1493         mplane_t clipplane;
1494         float frustum_x, frustum_y;
1495         vec3_t frustumcorner[4];
1496         // if turned off it renders an ortho view
1497         int useperspective;
1498         float ortho_x, ortho_y;
1499
1500         // screen area to render in
1501         int x;
1502         int y;
1503         int z;
1504         int width;
1505         int height;
1506         int depth;
1507         r_viewport_t viewport;
1508
1509         // which color components to allow (for anaglyph glasses)
1510         int colormask[4];
1511
1512         // global RGB color multiplier for rendering, this is required by HDR
1513         float colorscale;
1514
1515         // whether to call R_ClearScreen before rendering stuff
1516         qboolean clear;
1517         // if true, don't clear or do any post process effects (bloom, etc)
1518         qboolean isoverlay;
1519
1520         // whether to draw r_showtris and such, this is only true for the main
1521         // view render, all secondary renders (HDR, mirrors, portals, cameras,
1522         // distortion effects, etc) omit such debugging information
1523         qboolean showdebug;
1524
1525         // these define which values to use in GL_CullFace calls to request frontface or backface culling
1526         int cullface_front;
1527         int cullface_back;
1528
1529         // render quality (0 to 1) - affects r_drawparticles_drawdistance and others
1530         float quality;
1531 }
1532 r_refdef_view_t;
1533
1534 typedef struct r_refdef_viewcache_s
1535 {
1536         // these properties are generated by R_View_Update()
1537
1538         // which entities are currently visible for this viewpoint
1539         // (the used range is 0...r_refdef.scene.numentities)
1540         unsigned char entityvisible[MAX_EDICTS];
1541         // flag arrays used for visibility checking on world model
1542         // (all other entities have no per-surface/per-leaf visibility checks)
1543         // TODO: dynamic resize according to r_refdef.scene.worldmodel->brush.num_clusters
1544         unsigned char world_pvsbits[(32768+7)>>3]; // FIXME: buffer overflow on huge maps
1545         // TODO: dynamic resize according to r_refdef.scene.worldmodel->brush.num_leafs
1546         unsigned char world_leafvisible[32768]; // FIXME: buffer overflow on huge maps
1547         // TODO: dynamic resize according to r_refdef.scene.worldmodel->num_surfaces
1548         unsigned char world_surfacevisible[262144]; // FIXME: buffer overflow on huge maps
1549         // if true, the view is currently in a leaf without pvs data
1550         qboolean world_novis;
1551 }
1552 r_refdef_viewcache_t;
1553
1554 // TODO: really think about which fields should go into scene and which one should stay in refdef [1/7/2008 Black]
1555 // maybe also refactor some of the functions to support different setting sources (ie. fogenabled, etc.) for different scenes
1556 typedef struct r_refdef_scene_s {
1557         // whether to call S_ExtraUpdate during render to reduce sound chop
1558         qboolean extraupdate;
1559
1560         // (client gameworld) time for rendering time based effects
1561         double time;
1562
1563         // the world
1564         entity_render_t *worldentity;
1565
1566         // same as worldentity->model
1567         dp_model_t *worldmodel;
1568
1569         // renderable entities (excluding world)
1570         entity_render_t **entities;
1571         int numentities;
1572         int maxentities;
1573
1574         // field of temporary entities that is reset each (client) frame
1575         entity_render_t *tempentities;
1576         int numtempentities;
1577         int maxtempentities;
1578
1579         // renderable dynamic lights
1580         rtlight_t *lights[MAX_DLIGHTS];
1581         rtlight_t templights[MAX_DLIGHTS];
1582         int numlights;
1583
1584         // intensities for light styles right now, controls rtlights
1585         float rtlightstylevalue[256];   // float fraction of base light value
1586         // 8.8bit fixed point intensities for light styles
1587         // controls intensity lightmap layers
1588         unsigned short lightstylevalue[256];    // 8.8 fraction of base light value
1589
1590         float ambient;
1591
1592         qboolean rtworld;
1593         qboolean rtworldshadows;
1594         qboolean rtdlight;
1595         qboolean rtdlightshadows;
1596 } r_refdef_scene_t;
1597
1598 typedef struct r_refdef_s
1599 {
1600         // these fields define the basic rendering information for the world
1601         // but not the view, which could change multiple times in one rendered
1602         // frame (for example when rendering textures for certain effects)
1603
1604         // these are set for water warping before
1605         // frustum_x/frustum_y are calculated
1606         float frustumscale_x, frustumscale_y;
1607
1608         // current view settings (these get reset a few times during rendering because of water rendering, reflections, etc)
1609         r_refdef_view_t view;
1610         r_refdef_viewcache_t viewcache;
1611
1612         // minimum visible distance (pixels closer than this disappear)
1613         double nearclip;
1614         // maximum visible distance (pixels further than this disappear in 16bpp modes,
1615         // in 32bpp an infinite-farclip matrix is used instead)
1616         double farclip;
1617
1618         // fullscreen color blend
1619         float viewblend[4];
1620
1621         r_refdef_scene_t scene;
1622
1623         vec3_t fogcolor;
1624         vec_t fogrange;
1625         vec_t fograngerecip;
1626         vec_t fogmasktabledistmultiplier;
1627 #define FOGMASKTABLEWIDTH 1024
1628         float fogmasktable[FOGMASKTABLEWIDTH];
1629         float fogmasktable_start, fogmasktable_alpha, fogmasktable_range, fogmasktable_density;
1630         float fog_density;
1631         float fog_red;
1632         float fog_green;
1633         float fog_blue;
1634         float fog_alpha;
1635         float fog_start;
1636         float fog_end;
1637         qboolean fogenabled;
1638         qboolean oldgl_fogenable;
1639
1640         qboolean draw2dstage;
1641
1642         // true during envmap command capture
1643         qboolean envmap;
1644
1645         // brightness of world lightmaps and related lighting
1646         // (often reduced when world rtlights are enabled)
1647         float lightmapintensity;
1648         // whether to draw world lights realtime, dlights realtime, and their shadows
1649         float polygonfactor;
1650         float polygonoffset;
1651         float shadowpolygonfactor;
1652         float shadowpolygonoffset;
1653
1654         // rendering stats for r_speeds display
1655         // (these are incremented in many places)
1656         r_refdef_stats_t stats;
1657 }
1658 r_refdef_t;
1659
1660 extern r_refdef_t r_refdef;
1661
1662 #endif
1663