Lots of speedups and cleanups in client code, dynamically allocated cl_entities ...
[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 // LordHavoc: 256 dynamic lights
26 #define MAX_DLIGHTS 256
27 // LordHavoc: this affects the lighting scale of the whole game
28 #define LIGHTOFFSET 1024.0f
29 // max lights shining on one entity
30 #define MAXENTLIGHTS 128
31
32 extern int cl_max_entities;
33 extern int cl_max_static_entities;
34 extern int cl_max_temp_entities;
35 extern int cl_max_effects;
36 extern int cl_max_beams;
37
38 typedef struct effect_s
39 {
40         int active;
41         vec3_t origin;
42         float 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
55 {
56         int             entity;
57         struct model_s  *model;
58         float   endtime;
59         vec3_t  start, end;
60 }
61 beam_t;
62
63 typedef struct
64 {
65         // location
66         vec3_t  origin;
67         // stop lighting after this time
68         float   die;
69         // color of light
70         vec3_t  color;
71         // brightness (not really radius anymore)
72         float   radius;
73         // drop this each second
74         float   decay;
75         // the entity that spawned this light (can be NULL if it will never be replaced)
76         //entity_render_t *ent;
77 }
78 dlight_t;
79
80 typedef struct frameblend_s
81 {
82         int frame;
83         float lerp;
84 }
85 frameblend_t;
86
87 // LordHavoc: disregard the following warning, entlights stuff is semi-persistent...
88 // LordHavoc: nothing in this structure is persistent, it may be overwritten by the client every frame, for persistent data use entity_lerp_t.
89 typedef struct entity_render_s
90 {
91         // location
92         vec3_t origin;
93         // orientation
94         vec3_t angles;
95         // opacity (alpha) of the model
96         float alpha;
97         // size the model is shown
98         float scale;
99
100         // NULL = no model
101         model_t *model;
102         // current uninterpolated animation frame (for things which do not use interpolation)
103         int frame;
104         // entity shirt and pants colors
105         int colormap;
106         // light, particles, etc
107         int effects;
108         // for Alias models
109         int skinnum;
110         // render flags
111         int flags;
112
113         // these are copied from the persistent data
114
115         // frame that the model is interpolating from
116         int frame1;
117         // frame that the model is interpolating to
118         int frame2;
119         // interpolation factor, usually computed from frame2time
120         double framelerp;
121         // time frame1 began playing (for framegroup animations)
122         double frame1time;
123         // time frame2 began playing (for framegroup animations)
124         double frame2time;
125
126         // calculated by the renderer (but not persistent)
127
128         // if visframe == r_framecount, it is visible
129         int visframe;
130         // calculated during R_AddModelEntities
131         vec3_t mins, maxs;
132         // 4 frame numbers (-1 if not used) and their blending scalers (0-1), if interpolation is not desired, use frame instead
133         frameblend_t frameblend[4];
134
135         // caching results of static light traces (this is semi-persistent)
136         double entlightstime;
137         vec3_t entlightsorigin;
138         int numentlights;
139         unsigned short entlights[MAXENTLIGHTS];
140 }
141 entity_render_t;
142
143 typedef struct entity_persistent_s
144 {
145         // particles
146
147         // trail rendering
148         vec3_t trail_origin;
149         float trail_time;
150
151         // effects
152
153         // muzzleflash fading
154         float muzzleflash;
155
156         // interpolated animation
157
158         // lerp resets when model changes
159         int modelindex;
160         // frame that the model is interpolating from
161         int frame1;
162         // frame that the model is interpolating to
163         int frame2;
164         // interpolation factor, usually computed from frame2time
165         double framelerp;
166         // time frame1 began playing (for framegroup animations)
167         double frame1time;
168         // time frame2 began playing (for framegroup animations)
169         double frame2time;
170 }
171 entity_persistent_t;
172
173 typedef struct entity_s
174 {
175         // baseline state (default values)
176         entity_state_t state_baseline;
177         // previous state (interpolating from this)
178         entity_state_t state_previous;
179         // current state (interpolating to this)
180         entity_state_t state_current;
181
182         // used for regenerating parts of render
183         entity_persistent_t persistent;
184
185         // the only data the renderer should know about
186         entity_render_t render;
187 }
188 entity_t;
189
190 typedef struct
191 {
192         vec3_t  viewangles;
193
194 // intended velocities
195         float   forwardmove;
196         float   sidemove;
197         float   upmove;
198 } usercmd_t;
199
200 typedef struct
201 {
202         int             length;
203         char    map[MAX_STYLESTRING];
204 } lightstyle_t;
205
206 typedef struct
207 {
208         char    name[MAX_SCOREBOARDNAME];
209         float   entertime;
210         int             frags;
211         int             colors; // two 4 bit fields
212 } scoreboard_t;
213
214 typedef struct
215 {
216         int             destcolor[3];
217         int             percent;                // 0-256
218 } cshift_t;
219
220 #define CSHIFT_CONTENTS 0
221 #define CSHIFT_DAMAGE   1
222 #define CSHIFT_BONUS    2
223 #define CSHIFT_POWERUP  3
224 #define NUM_CSHIFTS             4
225
226 #define NAME_LENGTH     64
227
228
229 //
230 // client_state_t should hold all pieces of the client state
231 //
232
233 #define SIGNONS         4                       // signon messages to receive before connected
234
235 #define MAX_MAPSTRING   2048
236 #define MAX_DEMOS               8
237 #define MAX_DEMONAME    16
238
239 typedef enum
240 {
241         ca_dedicated,           // a dedicated server with no ability to start a client
242         ca_disconnected,        // full screen console with no connection
243         ca_connected            // valid netcon, talking to a server
244 }
245 cactive_t;
246
247 //
248 // the client_static_t structure is persistent through an arbitrary number
249 // of server connections
250 //
251 typedef struct
252 {
253         cactive_t state;
254
255 // personalization data sent to server
256         char mapstring[MAX_QPATH];
257         // to restart a level
258         //char spawnparms[MAX_MAPSTRING];
259
260 // demo loop control
261         // -1 = don't play demos
262         int demonum;
263         // list of demos in loop
264         char demos[MAX_DEMOS][MAX_DEMONAME];
265
266 // demo recording info must be here, because record is started before
267 // entering a map (and clearing client_state_t)
268         qboolean demorecording;
269         qboolean demoplayback;
270         qboolean timedemo;
271         // -1 = use normal cd track
272         int forcetrack;
273         QFile *demofile;
274         // to meter out one message a frame
275         int td_lastframe;
276         // host_framecount at start
277         int td_startframe;
278         // realtime at second frame of timedemo (LordHavoc: changed to double)
279         double td_starttime;
280         // LordHavoc: pausedemo
281         qboolean demopaused;
282
283
284 // connection information
285         // 0 to SIGNONS
286         int signon;
287         // network socket
288         struct qsocket_s *netcon;
289         // writing buffer to send to server
290         sizebuf_t message;
291 }
292 client_static_t;
293
294 extern client_static_t  cls;
295
296 //
297 // the client_state_t structure is wiped completely at every
298 // server signon
299 //
300 typedef struct
301 {
302         // when connecting to the server throw out the first couple move messages
303         // so the player doesn't accidentally do something the first frame
304         int movemessages;
305
306         // send a clc_nop periodically until connected
307         float sendnoptime;
308
309         // last command sent to the server
310         usercmd_t cmd;
311
312 // information for local display
313         // health, etc
314         int stats[MAX_CL_STATS];
315         // inventory bit flags
316         int items;
317         // cl.time of acquiring item, for blinking
318         float item_gettime[32];
319         // use pain anim frame if cl.time < this
320         float faceanimtime;
321
322         // color shifts for damage, powerups
323         cshift_t cshifts[NUM_CSHIFTS];
324         // and content types
325         cshift_t prev_cshifts[NUM_CSHIFTS];
326
327 // the client maintains its own idea of view angles, which are
328 // sent to the server each frame.  The server sets punchangle when
329 // the view is temporarily offset, and an angle reset commands at the start
330 // of each level and after teleporting.
331
332         // during demo playback viewangles is lerped between these
333         vec3_t mviewangles[2];
334         // either client controlled, or lerped from demo mviewangles
335         vec3_t viewangles;
336
337         // update by server, used for lean+bob (0 is newest)
338         vec3_t mvelocity[2];
339         // lerped between mvelocity[0] and [1]
340         vec3_t velocity;
341
342         // temporary offset
343         vec3_t punchangle;
344         // LordHavoc: origin view kick
345         vec3_t punchvector;
346
347 // pitch drifting vars
348         float idealpitch;
349         float pitchvel;
350         qboolean nodrift;
351         float driftmove;
352         double laststop;
353
354         float viewheight;
355         // local amount for smoothing stepups
356         //float crouch;
357
358         // sent by server
359         qboolean paused;
360         qboolean onground;
361         qboolean inwater;
362
363         // don't change view angle, full screen, etc
364         int intermission;
365         // latched at intermission start
366         int completed_time;
367
368         // the timestamp of the last two messages
369         double mtime[2];
370
371         // clients view of time, time should be between mtime[0] and mtime[1] to
372         // generate a lerp point for other data, oldtime is the previous frame's
373         // value of time, frametime is the difference between time and oldtime
374         double time, oldtime, frametime;
375
376         // copy of realtime from last recieved message, for net trouble icon
377         float last_received_message;
378
379 // information that is static for the entire time connected to a server
380         struct model_s *model_precache[MAX_MODELS];
381         struct sfx_s *sound_precache[MAX_SOUNDS];
382
383         // for display on solo scoreboard
384         char levelname[40];
385         // cl_entitites[cl.viewentity] = player
386         int viewentity;
387         int maxclients;
388         int gametype;
389
390 // refresh related state
391
392         // cl_entitites[0].model
393         struct model_s *worldmodel;
394
395         // the gun model
396         entity_t viewent;
397
398         // cd audio
399         int cdtrack, looptrack;
400
401 // frag scoreboard
402
403         // [cl.maxclients]
404         scoreboard_t *scores;
405
406         // used by view code for setting up eye position
407         vec3_t viewentorigin;
408         // LordHavoc: sniping zoom, QC controlled
409         float viewzoom;
410         // for interpolation
411         float viewzoomold, viewzoomnew;
412
413         // entity database stuff
414         vec3_t viewentoriginold, viewentoriginnew;
415         entity_database_t entitydatabase;
416 }
417 client_state_t;
418
419 extern mempool_t *cl_scores_mempool;
420
421 //
422 // cvars
423 //
424 extern cvar_t cl_name;
425 extern cvar_t cl_color;
426 extern cvar_t cl_pmodel;
427
428 extern cvar_t cl_upspeed;
429 extern cvar_t cl_forwardspeed;
430 extern cvar_t cl_backspeed;
431 extern cvar_t cl_sidespeed;
432
433 extern cvar_t cl_movespeedkey;
434
435 extern cvar_t cl_yawspeed;
436 extern cvar_t cl_pitchspeed;
437
438 extern cvar_t cl_anglespeedkey;
439
440 extern cvar_t cl_autofire;
441
442 extern cvar_t cl_shownet;
443 extern cvar_t cl_nolerp;
444
445 extern cvar_t cl_pitchdriftspeed;
446 extern cvar_t lookspring;
447 extern cvar_t lookstrafe;
448 extern cvar_t sensitivity;
449
450 extern cvar_t freelook;
451
452 extern cvar_t m_pitch;
453 extern cvar_t m_yaw;
454 extern cvar_t m_forward;
455 extern cvar_t m_side;
456
457 extern cvar_t r_draweffects;
458
459 extern cvar_t cl_explosions;
460 extern cvar_t cl_stainmaps;
461
462 // these are updated by
463 extern int cl_num_entities;
464 extern int cl_num_static_entities;
465 extern int cl_num_temp_entities;
466 extern int cl_num_brushmodel_entities;
467
468 extern entity_t *cl_entities;
469 extern entity_t *cl_static_entities;
470 extern entity_t *cl_temp_entities;
471 extern entity_render_t **cl_brushmodel_entities;
472 extern cl_effect_t *cl_effects;
473 extern beam_t *cl_beams;
474 extern dlight_t *cl_dlights;
475 extern lightstyle_t *cl_lightstyle;
476
477
478 extern client_state_t cl;
479
480 extern void CL_AllocDlight (entity_render_t *ent, vec3_t org, float radius, float red, float green, float blue, float decay, float lifetime);
481 extern void CL_DecayLights (void);
482
483 //=============================================================================
484
485 //
486 // cl_main
487 //
488
489 void CL_Init (void);
490
491 void CL_EstablishConnection (char *host);
492
493 void CL_Disconnect (void);
494 void CL_Disconnect_f (void);
495
496 //
497 // cl_input
498 //
499 typedef struct
500 {
501         int             down[2];                // key nums holding it down
502         int             state;                  // low bit is down state
503 }
504 kbutton_t;
505
506 extern  kbutton_t       in_mlook, in_klook;
507 extern  kbutton_t       in_strafe;
508 extern  kbutton_t       in_speed;
509
510 void CL_InitInput (void);
511 void CL_SendCmd (void);
512 void CL_SendMove (usercmd_t *cmd);
513
514 void CL_LerpUpdate(entity_t *e);
515 void CL_ParseTEnt (void);
516 void CL_RelinkBeams (void);
517
518 void CL_ClearTempEntities (void);
519 entity_t *CL_NewTempEntity (void);
520
521 void CL_Effect(vec3_t org, int modelindex, int startframe, int framecount, float framerate);
522
523 void CL_ClearState (void);
524
525
526 int  CL_ReadFromServer (void);
527 void CL_WriteToServer (usercmd_t *cmd);
528 void CL_BaseMove (usercmd_t *cmd);
529
530
531 float CL_KeyState (kbutton_t *key);
532 char *Key_KeynumToString (int keynum);
533
534 //
535 // cl_demo.c
536 //
537 void CL_StopPlayback (void);
538 int CL_GetMessage (void);
539
540 void CL_NextDemo (void);
541 void CL_Stop_f (void);
542 void CL_Record_f (void);
543 void CL_PlayDemo_f (void);
544 void CL_TimeDemo_f (void);
545
546 //
547 // cl_parse.c
548 //
549 void CL_Parse_Init(void);
550 void CL_ParseServerMessage(void);
551 void CL_BitProfile_f(void);
552
553 //
554 // view
555 //
556 void V_StartPitchDrift (void);
557 void V_StopPitchDrift (void);
558
559 void V_Init (void);
560 float V_CalcRoll (vec3_t angles, vec3_t velocity);
561 void V_UpdateBlends (void);
562 void V_ParseDamage (void);
563
564
565 //
566 // cl_tent
567 //
568 void CL_InitTEnts (void);
569
570 //
571 // cl_part
572 //
573
574 #define PARTICLE_INVALID 0
575 #define PARTICLE_BILLBOARD 1
576 #define PARTICLE_UPRIGHT_FACING 2
577 #define PARTICLE_ORIENTED_DOUBLESIDED 3
578
579 void CL_Particles_Clear(void);
580 void CL_Particles_Init(void);
581
582 void CL_ParseParticleEffect (void);
583 void CL_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count);
584 void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent);
585 void CL_RocketTrail2 (vec3_t start, vec3_t end, int color, entity_t *ent);
586 void CL_SparkShower (vec3_t org, vec3_t dir, int count);
587 void CL_PlasmaBurn (vec3_t org);
588 void CL_BloodPuff (vec3_t org, vec3_t vel, int count);
589 void CL_Stardust (vec3_t mins, vec3_t maxs, int count);
590 void CL_FlameCube (vec3_t mins, vec3_t maxs, int count);
591 void CL_Flames (vec3_t org, vec3_t vel, int count);
592 void CL_BloodShower (vec3_t mins, vec3_t maxs, float velspeed, int count);
593 void CL_ParticleCube (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int colorbase, int gravity, int randomvel);
594 void CL_ParticleRain (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int colorbase, int type);
595 void CL_EntityParticles (entity_t *ent);
596 void CL_BlobExplosion (vec3_t org);
597 void CL_ParticleExplosion (vec3_t org, int smoke);
598 void CL_ParticleExplosion2 (vec3_t org, int colorStart, int colorLength);
599 void CL_LavaSplash (vec3_t org);
600 void CL_TeleportSplash (vec3_t org);
601 void CL_MoveParticles(void);
602 void R_MoveExplosions(void);
603 void R_NewExplosion(vec3_t org);
604
605 #include "cl_screen.h"
606
607 typedef struct
608 {
609         // area to render in
610         int x, y, width, height;
611         float fov_x, fov_y;
612
613         // view point
614         vec3_t vieworg;
615         vec3_t viewangles;
616
617         // fullscreen color blend
618         float viewblend[4];
619
620         // weapon model
621         entity_render_t viewent;
622
623         entity_render_t **entities;
624         int numentities;
625         int maxentities;
626
627         qbyte *drawqueue;
628         int drawqueuesize;
629         int maxdrawqueuesize;
630 }
631 refdef_t;
632
633 refdef_t r_refdef;
634
635 extern mempool_t *cl_refdef_mempool;
636
637 #include "cgamevm.h"
638
639 #endif
640