X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=client.h;h=1dd0df3c32fc2b5f7efbe2bd6edd37c58add3573;hp=9abe25e25db9fa00d82a4ac196c90a60fdb80dcc;hb=798d907bb916ac4f89e854794a28540913b71b01;hpb=e4b3858e7aca0ead91be1d8f675db084d025abad diff --git a/client.h b/client.h index 9abe25e2..1dd0df3c 100644 --- a/client.h +++ b/client.h @@ -8,7 +8,7 @@ of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. @@ -19,6 +19,193 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ // client.h +#ifndef CLIENT_H +#define CLIENT_H + +#include "matrixlib.h" + +// LordHavoc: 256 dynamic lights +#define MAX_DLIGHTS 256 +// LordHavoc: this affects the lighting scale of the whole game +#define LIGHTOFFSET 1024.0f +// max lights shining on one entity +#define MAXENTLIGHTS 128 + +extern int cl_max_entities; +extern int cl_max_static_entities; +extern int cl_max_temp_entities; +extern int cl_max_effects; +extern int cl_max_beams; + +typedef struct effect_s +{ + int active; + vec3_t origin; + float starttime; + float framerate; + int modelindex; + int startframe; + int endframe; + // these are for interpolation + int frame; + double frame1time; + double frame2time; +} +cl_effect_t; + +typedef struct +{ + int entity; + struct model_s *model; + float endtime; + vec3_t start, end; +} +beam_t; + +typedef struct +{ + // location + vec3_t origin; + // stop lighting after this time + float die; + // color of light + vec3_t color; + // brightness (not really radius anymore) + float radius; + // drop this each second + float decay; + // the entity that spawned this light (can be NULL if it will never be replaced) + //entity_render_t *ent; +} +dlight_t; + +typedef struct frameblend_s +{ + int frame; + float lerp; +} +frameblend_t; + +// LordHavoc: disregard the following warning, entlights stuff is semi-persistent... +// LordHavoc: nothing in this structure is persistent, it may be overwritten by the client every frame, for persistent data use entity_lerp_t. +typedef struct entity_render_s +{ + // location + vec3_t origin; + // orientation + vec3_t angles; + // transform matrix for model to world + matrix4x4_t matrix; + // transform matrix for world to model + matrix4x4_t inversematrix; + // opacity (alpha) of the model + float alpha; + // size the model is shown + float scale; + + // NULL = no model + model_t *model; + // current uninterpolated animation frame (for things which do not use interpolation) + int frame; + // entity shirt and pants colors + int colormap; + // light, particles, etc + int effects; + // for Alias models + int skinnum; + // render flags + int flags; + + // these are copied from the persistent data + + // frame that the model is interpolating from + int frame1; + // frame that the model is interpolating to + int frame2; + // interpolation factor, usually computed from frame2time + double framelerp; + // time frame1 began playing (for framegroup animations) + double frame1time; + // time frame2 began playing (for framegroup animations) + double frame2time; + + // calculated by the renderer (but not persistent) + + // if visframe == r_framecount, it is visible + int visframe; + // calculated during R_AddModelEntities + vec3_t mins, maxs; + // 4 frame numbers (-1 if not used) and their blending scalers (0-1), if interpolation is not desired, use frame instead + frameblend_t frameblend[4]; + + // caching results of static light traces (this is semi-persistent) + double entlightstime; + vec3_t entlightsorigin; + int entlightsframe; + int numentlights; + unsigned short entlights[MAXENTLIGHTS]; +} +entity_render_t; + +typedef struct entity_persistent_s +{ + // particles + + // trail rendering + vec3_t trail_origin; + float trail_time; + + // effects + + // muzzleflash fading + float muzzleflash; + + // interpolated movement + + // start time of move + float lerpstarttime; + // time difference from start to end of move + float lerpdeltatime; + // the move itself, start and end + float oldorigin[3]; + float oldangles[3]; + float neworigin[3]; + float newangles[3]; + + // interpolated animation + + // lerp resets when model changes + int modelindex; + // frame that the model is interpolating from + int frame1; + // frame that the model is interpolating to + int frame2; + // interpolation factor, usually computed from frame2time + double framelerp; + // time frame1 began playing (for framegroup animations) + double frame1time; + // time frame2 began playing (for framegroup animations) + double frame2time; +} +entity_persistent_t; + +typedef struct entity_s +{ + // baseline state (default values) + entity_state_t state_baseline; + // previous state (interpolating from this) + entity_state_t state_previous; + // current state (interpolating to this) + entity_state_t state_current; + + // used for regenerating parts of render + entity_persistent_t persistent; + + // the only data the renderer should know about + entity_render_t render; +} +entity_t; + typedef struct { vec3_t viewangles; @@ -40,8 +227,7 @@ typedef struct char name[MAX_SCOREBOARDNAME]; float entertime; int frags; - int colors; // two 4 bit fields -// byte translations[256]; // LordHavoc: major memory reduction (was VID_GRADES*256, and VID_GRADES is 64), and weirdness cleanup + int colors; // two 4 bit fields } scoreboard_t; typedef struct @@ -65,65 +251,58 @@ typedef struct #define SIGNONS 4 // signon messages to receive before connected -#include "r_light.h" - -#define MAX_BEAMS 24 -typedef struct -{ - int entity; - struct model_s *model; - float endtime; - vec3_t start, end; -} beam_t; - -// LordHavoc: increased MAX_EFRAGS from 640 to 2048 -#define MAX_EFRAGS 2048 - -#define MAX_MAPSTRING 2048 #define MAX_DEMOS 8 #define MAX_DEMONAME 16 -typedef enum { -ca_dedicated, // a dedicated server with no ability to start a client -ca_disconnected, // full screen console with no connection -ca_connected // valid netcon, talking to a server -} cactive_t; +typedef enum +{ + ca_dedicated, // a dedicated server with no ability to start a client + ca_disconnected, // full screen console with no connection + ca_connected // valid netcon, talking to a server +} +cactive_t; // -// the client_static_t structure is persistant through an arbitrary number +// the client_static_t structure is persistent through an arbitrary number // of server connections // typedef struct { - cactive_t state; - -// personalization data sent to server - char mapstring[MAX_QPATH]; - char spawnparms[MAX_MAPSTRING]; // to restart a level + cactive_t state; // demo loop control - int demonum; // -1 = don't play demos - char demos[MAX_DEMOS][MAX_DEMONAME]; // when not playing + // -1 = don't play demos + int demonum; + // list of demos in loop + char demos[MAX_DEMOS][MAX_DEMONAME]; // demo recording info must be here, because record is started before // entering a map (and clearing client_state_t) - qboolean demorecording; - qboolean demoplayback; - qboolean timedemo; - int forcetrack; // -1 = use normal cd track - FILE *demofile; - int td_lastframe; // to meter out one message a frame - int td_startframe; // host_framecount at start - double td_starttime; // realtime at second frame of timedemo (LordHavoc: changed to double) - qboolean demopaused; // LordHavoc: pausedemo + qboolean demorecording; + qboolean demoplayback; + qboolean timedemo; + // -1 = use normal cd track + int forcetrack; + QFile *demofile; + // to meter out one message a frame + int td_lastframe; + // host_framecount at start + int td_startframe; + // realtime at second frame of timedemo (LordHavoc: changed to double) + double td_starttime; + // LordHavoc: pausedemo + qboolean demopaused; // connection information - int signon; // 0 to SIGNONS - struct qsocket_s *netcon; - sizebuf_t message; // writing buffer to send to server - -} client_static_t; + // 0 to SIGNONS + int signon; + // network socket + struct qsocket_s *netcon; + // writing buffer to send to server + sizebuf_t message; +} +client_static_t; extern client_static_t cls; @@ -133,164 +312,207 @@ extern client_static_t cls; // typedef struct { - int movemessages; // since connecting to this server - // throw out the first couple, so the player - // doesn't accidentally do something the - // first frame - usercmd_t cmd; // last command sent to the server + // when connecting to the server throw out the first couple move messages + // so the player doesn't accidentally do something the first frame + int movemessages; -// information for local display - int stats[MAX_CL_STATS]; // health, etc - int items; // inventory bit flags - float item_gettime[32]; // cl.time of aquiring item, for blinking - float faceanimtime; // use anim frame if cl.time < this + // send a clc_nop periodically until connected + float sendnoptime; - cshift_t cshifts[NUM_CSHIFTS]; // color shifts for damage, powerups - cshift_t prev_cshifts[NUM_CSHIFTS]; // and content types + // last command sent to the server + usercmd_t cmd; + +// information for local display + // health, etc + int stats[MAX_CL_STATS]; + // inventory bit flags + int items; + // cl.time of acquiring item, for blinking + float item_gettime[32]; + // use pain anim frame if cl.time < this + float faceanimtime; + + // color shifts for damage, powerups + cshift_t cshifts[NUM_CSHIFTS]; + // and content types + cshift_t prev_cshifts[NUM_CSHIFTS]; // the client maintains its own idea of view angles, which are // sent to the server each frame. The server sets punchangle when -// the view is temporarliy offset, and an angle reset commands at the start +// the view is temporarily offset, and an angle reset commands at the start // of each level and after teleporting. - vec3_t mviewangles[2]; // during demo playback viewangles is lerped - // between these - vec3_t viewangles; - - vec3_t mvelocity[2]; // update by server, used for lean+bob - // (0 is newest) - vec3_t velocity; // lerped between mvelocity[0] and [1] - - vec3_t punchangle; // temporary offset - vec3_t punchvector; // LordHavoc: origin view kick - + + // during demo playback viewangles is lerped between these + vec3_t mviewangles[2]; + // either client controlled, or lerped from demo mviewangles + vec3_t viewangles; + + // update by server, used for lean+bob (0 is newest) + vec3_t mvelocity[2]; + // lerped between mvelocity[0] and [1] + vec3_t velocity; + + // temporary offset + vec3_t punchangle; + // LordHavoc: origin view kick + vec3_t punchvector; + // pitch drifting vars - float idealpitch; - float pitchvel; - qboolean nodrift; - float driftmove; - double laststop; - - float viewheight; - float crouch; // local amount for smoothing stepups - - qboolean paused; // send over by server - qboolean onground; - qboolean inwater; - - int intermission; // don't change view angle, full screen, etc - int completed_time; // latched at intermission start - - double mtime[2]; // the timestamp of last two messages - double time; // clients view of time, should be between - // servertime and oldservertime to generate - // a lerp point for other data - double oldtime; // previous cl.time, time-oldtime is used - // to decay light values and smooth step ups - - double frametime; - - - float last_received_message; // (realtime) for net trouble icon + float idealpitch; + float pitchvel; + qboolean nodrift; + float driftmove; + double laststop; -// -// information that is static for the entire time connected to a server -// - struct model_s *model_precache[MAX_MODELS]; - struct sfx_s *sound_precache[MAX_SOUNDS]; + float viewheight; + // local amount for smoothing stepups + //float crouch; + + // sent by server + qboolean paused; + qboolean onground; + qboolean inwater; - char levelname[40]; // for display on solo scoreboard - int viewentity; // cl_entitites[cl.viewentity] = player - int maxclients; - int gametype; + // don't change view angle, full screen, etc + int intermission; + // latched at intermission start + int completed_time; + + // the timestamp of the last two messages + double mtime[2]; + + // clients view of time, time should be between mtime[0] and mtime[1] to + // generate a lerp point for other data, oldtime is the previous frame's + // value of time, frametime is the difference between time and oldtime + double time, oldtime, frametime; + + // copy of realtime from last recieved message, for net trouble icon + float last_received_message; + +// information that is static for the entire time connected to a server + struct model_s *model_precache[MAX_MODELS]; + struct sfx_s *sound_precache[MAX_SOUNDS]; + + // for display on solo scoreboard + char levelname[40]; + // cl_entitites[cl.viewentity] = player + int viewentity; + // the real player entity (normally same as viewentity, + // different than viewentity if mod uses chasecam or other tricks) + int playerentity; + // max players that can be in this game + int maxclients; + // type of game (deathmatch, coop, singleplayer) + int gametype; // refresh related state - struct model_s *worldmodel; // cl_entitites[0].model - struct efrag_s *free_efrags; - int num_entities; // held in cl_entities array - int num_statics; // held in cl_staticentities array - entity_t viewent; // the gun model - int cdtrack, looptrack; // cd audio + // cl_entitites[0].model + struct model_s *worldmodel; + + // the gun model + entity_t viewent; + + // cd audio + int cdtrack, looptrack; // frag scoreboard - scoreboard_t *scores; // [cl.maxclients] -} client_state_t; + // [cl.maxclients] + scoreboard_t *scores; + + // used by view code for setting up eye position + vec3_t viewentorigin; + // LordHavoc: sniping zoom, QC controlled + float viewzoom; + // for interpolation + float viewzoomold, viewzoomnew; + + // entity database stuff + vec3_t viewentoriginold, viewentoriginnew; + entity_database_t entitydatabase; +} +client_state_t; + +extern mempool_t *cl_scores_mempool; // // cvars // -extern cvar_t cl_name; -extern cvar_t cl_color; -extern cvar_t cl_pmodel; +extern cvar_t cl_name; +extern cvar_t cl_color; +extern cvar_t cl_pmodel; -extern cvar_t cl_upspeed; -extern cvar_t cl_forwardspeed; -extern cvar_t cl_backspeed; -extern cvar_t cl_sidespeed; +extern cvar_t cl_upspeed; +extern cvar_t cl_forwardspeed; +extern cvar_t cl_backspeed; +extern cvar_t cl_sidespeed; -extern cvar_t cl_movespeedkey; +extern cvar_t cl_movespeedkey; -extern cvar_t cl_yawspeed; -extern cvar_t cl_pitchspeed; +extern cvar_t cl_yawspeed; +extern cvar_t cl_pitchspeed; -extern cvar_t cl_anglespeedkey; +extern cvar_t cl_anglespeedkey; -extern cvar_t cl_autofire; +extern cvar_t cl_autofire; -extern cvar_t cl_shownet; -extern cvar_t cl_nolerp; +extern cvar_t cl_shownet; +extern cvar_t cl_nolerp; -extern cvar_t cl_pitchdriftspeed; -extern cvar_t lookspring; -extern cvar_t lookstrafe; -extern cvar_t sensitivity; +extern cvar_t cl_pitchdriftspeed; +extern cvar_t lookspring; +extern cvar_t lookstrafe; +extern cvar_t sensitivity; -extern cvar_t m_pitch; -extern cvar_t m_yaw; -extern cvar_t m_forward; -extern cvar_t m_side; +extern cvar_t freelook; +extern cvar_t m_pitch; +extern cvar_t m_yaw; +extern cvar_t m_forward; +extern cvar_t m_side; -// LordHavoc: raised these from 64 and 128 to 512 and 256 -#define MAX_TEMP_ENTITIES 512 // lightning bolts, effects, etc -#define MAX_STATIC_ENTITIES 256 // torches, etc +extern cvar_t r_draweffects; -extern client_state_t cl; +extern cvar_t cl_explosions; +extern cvar_t cl_stainmaps; -// FIXME, allocate dynamically -extern efrag_t cl_efrags[MAX_EFRAGS]; -extern entity_t cl_entities[MAX_EDICTS]; -extern entity_t cl_static_entities[MAX_STATIC_ENTITIES]; -extern lightstyle_t cl_lightstyle[MAX_LIGHTSTYLES]; -extern dlight_t cl_dlights[MAX_DLIGHTS]; -extern entity_t cl_temp_entities[MAX_TEMP_ENTITIES]; -extern beam_t cl_beams[MAX_BEAMS]; +// these are updated by CL_ClearState +extern int cl_num_entities; +extern int cl_num_static_entities; +extern int cl_num_temp_entities; +extern int cl_num_brushmodel_entities; + +extern entity_t *cl_entities; +extern qbyte *cl_entities_active; +extern entity_t *cl_static_entities; +extern entity_t *cl_temp_entities; +extern entity_render_t **cl_brushmodel_entities; +extern cl_effect_t *cl_effects; +extern beam_t *cl_beams; +extern dlight_t *cl_dlights; +extern lightstyle_t *cl_lightstyle; + + +extern client_state_t cl; + +extern void CL_AllocDlight (entity_render_t *ent, vec3_t org, float radius, float red, float green, float blue, float decay, float lifetime); +extern void CL_DecayLights (void); //============================================================================= // // cl_main // -dlight_t *CL_AllocDlight (int key); -void CL_DecayLights (void); void CL_Init (void); void CL_EstablishConnection (char *host); -void CL_Signon1 (void); -void CL_Signon2 (void); -void CL_Signon3 (void); -void CL_Signon4 (void); void CL_Disconnect (void); void CL_Disconnect_f (void); -void CL_NextDemo (void); -// LordHavoc: raised this from 256 to the maximum possible number of entities visible -#define MAX_VISEDICTS (MAX_EDICTS + MAX_STATIC_ENTITIES + MAX_TEMP_ENTITIES) -extern int cl_numvisedicts; -extern entity_t *cl_visedicts[MAX_VISEDICTS]; +void CL_BoundingBoxForEntity(entity_render_t *ent); // // cl_input @@ -299,7 +521,8 @@ typedef struct { int down[2]; // key nums holding it down int state; // low bit is down state -} kbutton_t; +} +kbutton_t; extern kbutton_t in_mlook, in_klook; extern kbutton_t in_strafe; @@ -309,10 +532,11 @@ void CL_InitInput (void); void CL_SendCmd (void); void CL_SendMove (usercmd_t *cmd); +void CL_LerpUpdate(entity_t *e); void CL_ParseTEnt (void); -void CL_UpdateTEnts (void); -void CL_DoEffects (void); +void CL_RelinkBeams (void); +void CL_ClearTempEntities (void); entity_t *CL_NewTempEntity (void); void CL_Effect(vec3_t org, int modelindex, int startframe, int framecount, float framerate); @@ -334,6 +558,7 @@ char *Key_KeynumToString (int keynum); void CL_StopPlayback (void); int CL_GetMessage (void); +void CL_NextDemo (void); void CL_Stop_f (void); void CL_Record_f (void); void CL_PlayDemo_f (void); @@ -342,7 +567,8 @@ void CL_TimeDemo_f (void); // // cl_parse.c // -void CL_ParseServerMessage (void); +void CL_Parse_Init(void); +void CL_ParseServerMessage(void); // // view @@ -350,15 +576,82 @@ void CL_ParseServerMessage (void); void V_StartPitchDrift (void); void V_StopPitchDrift (void); -void V_RenderView (void); +void V_Init (void); +float V_CalcRoll (vec3_t angles, vec3_t velocity); void V_UpdateBlends (void); -void V_Register (void); void V_ParseDamage (void); -void V_SetContentsColor (int contents); // // cl_tent // void CL_InitTEnts (void); -void CL_SignonReply (void); + +// +// cl_part +// + +void CL_Particles_Clear(void); +void CL_Particles_Init(void); + +void CL_ParseParticleEffect (void); +void CL_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count); +void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent); +void CL_RocketTrail2 (vec3_t start, vec3_t end, int color, entity_t *ent); +void CL_SparkShower (vec3_t org, vec3_t dir, int count); +void CL_PlasmaBurn (vec3_t org); +void CL_BloodPuff (vec3_t org, vec3_t vel, int count); +void CL_Stardust (vec3_t mins, vec3_t maxs, int count); +void CL_FlameCube (vec3_t mins, vec3_t maxs, int count); +void CL_Flames (vec3_t org, vec3_t vel, int count); +void CL_BloodShower (vec3_t mins, vec3_t maxs, float velspeed, int count); +void CL_ParticleCube (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int colorbase, int gravity, int randomvel); +void CL_ParticleRain (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int colorbase, int type); +void CL_EntityParticles (entity_t *ent); +void CL_BlobExplosion (vec3_t org); +void CL_ParticleExplosion (vec3_t org); +void CL_ParticleExplosion2 (vec3_t org, int colorStart, int colorLength); +void CL_LavaSplash (vec3_t org); +void CL_TeleportSplash (vec3_t org); +void CL_MoveParticles(void); +void R_MoveExplosions(void); +void R_NewExplosion(vec3_t org); + +#include "cl_screen.h" + +typedef struct +{ + // area to render in + int x, y, width, height; + float fov_x, fov_y; + + // view point + vec3_t vieworg; + vec3_t viewangles; + + // fullscreen color blend + float viewblend[4]; + + // weapon model + entity_render_t viewent; + + entity_render_t **entities; + int numentities; + int maxentities; + + qbyte *drawqueue; + int drawqueuesize; + int maxdrawqueuesize; +} +refdef_t; + +refdef_t r_refdef; + +extern mempool_t *cl_refdef_mempool; + +#include "cgamevm.h" + +void Host_PerformSpawnServerAndLoadGame(void); + +#endif +