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