X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=client.h;h=cb36d4d4aa3564a817b7f15e40a70df4e874f676;hb=eacd06327dd5ac3be3800d102e5b56a1efd051b0;hp=870e6129d6f15d66ca0823692587527ed963fde4;hpb=4912a987528b78fa5cd322952acddd45ceba54d8;p=xonotic%2Fdarkplaces.git diff --git a/client.h b/client.h index 870e6129..cb36d4d4 100644 --- a/client.h +++ b/client.h @@ -31,11 +31,9 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. // 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; +// flags for rtlight rendering +#define LIGHTFLAG_NORMALMODE 1 +#define LIGHTFLAG_REALTIMEMODE 2 typedef struct effect_s { @@ -53,7 +51,7 @@ typedef struct effect_s } cl_effect_t; -typedef struct +typedef struct beam_s { int entity; // draw this as lightning polygons, or a model? @@ -72,31 +70,36 @@ beam_t; typedef struct rtlight_s { - // shadow volumes are done entirely in model space, so there are no matrices for dealing with them... they just use the origin + // shadow volumes are done entirely in model space, so there are no matrices for dealing with them... they just use the origin // note that the world to light matrices are inversely scaled (divided) by lightradius // core properties // matrix for transforming world coordinates to light filter coordinates matrix4x4_t matrix_worldtolight; - // based on worldtolight this transforms -1 to +1 to 0 to 1 for purposes - // of attenuation texturing in full 3D (Z result often ignored) - matrix4x4_t matrix_worldtoattenuationxyz; - // this transforms only the Z to S, and T is always 0.5 - matrix4x4_t matrix_worldtoattenuationz; // typically 1 1 1, can be lower (dim) or higher (overbright) vec3_t color; // size of the light (remove?) vec_t radius; // light filter char cubemapname[64]; + // light style to monitor for brightness + int style; // whether light should render shadows int shadow; // intensity of corona to render vec_t corona; - // light style to monitor for brightness - int style; - + // radius scale of corona to render (1.0 means same as light radius) + vec_t coronasizescale; + // ambient intensity to render + vec_t ambientscale; + // diffuse intensity to render + vec_t diffusescale; + // specular intensity to render + vec_t specularscale; + // LIGHTFLAG_* flags + int flags; + // generated properties // used only for shadow volumes vec3_t shadoworigin; @@ -104,9 +107,15 @@ typedef struct rtlight_s vec3_t cullmins; vec3_t cullmaxs; // culling - vec_t cullradius; + //vec_t cullradius; // squared cullradius - vec_t cullradius2; + //vec_t cullradius2; + + // rendering properties, updated each time a light is rendered + // this is rtlight->color * d_lightstylevalue + vec3_t currentcolor; + // this is R_Shadow_Cubemap(rtlight->cubemapname) + rtexture_t *currentcubemap; // lightmap renderer stuff (remove someday!) // the size of the light @@ -123,12 +132,16 @@ typedef struct rtlight_s int isstatic; // true if this is a compiled world light, cleared if the light changes int compiled; - // premade shadow volumes and lit surfaces to render for world entity + // premade shadow volumes to render for world entity shadowmesh_t *static_meshchain_shadow; - shadowmesh_t *static_meshchain_light; // used for visibility testing (more exact than bbox) - int static_numclusters; - int *static_clusterindices; + int static_numleafs; + int static_numleafpvsbytes; + int *static_leaflist; + unsigned char *static_leafpvs; + // surfaces seen by light + int static_numsurfaces; + int *static_surfacelist; } rtlight_t; @@ -178,11 +191,26 @@ typedef struct dlight_s // corona intensity // (worldlight: saved to .rtlights file) vec_t corona; + // radius scale of corona to render (1.0 means same as light radius) + // (worldlight: saved to .rtlights file) + vec_t coronasizescale; + // ambient intensity to render + // (worldlight: saved to .rtlights file) + vec_t ambientscale; + // diffuse intensity to render + // (worldlight: saved to .rtlights file) + vec_t diffusescale; + // specular intensity to render + // (worldlight: saved to .rtlights file) + vec_t specularscale; + // LIGHTFLAG_* flags + // (worldlight: saved to .rtlights file) + int flags; // linked list of world lights // (worldlight only) struct dlight_s *next; // embedded rtlight struct for renderer - // (renderer only) + // (renderer only) rtlight_t rtlight; } dlight_t; @@ -215,8 +243,11 @@ typedef struct entity_render_s model_t *model; // current uninterpolated animation frame (for things which do not use interpolation) int frame; - // entity shirt and pants colors + // entity shirt and pants colors (-1 if not colormapped) int colormap; + // literal colors for renderer + vec3_t colormap_pantscolor; + vec3_t colormap_shirtcolor; // light, particles, etc int effects; // for Alias models @@ -224,6 +255,9 @@ typedef struct entity_render_s // render flags int flags; + // colormod tinting of models + float colormod[3]; + // interpolated animation // frame that the model is interpolating from @@ -283,6 +317,7 @@ entity_persistent_t; typedef struct entity_s { + qboolean csqc; // baseline state (default values) entity_state_t state_baseline; // previous state (interpolating from this) @@ -298,7 +333,7 @@ typedef struct entity_s } entity_t; -typedef struct +typedef struct usercmd_s { vec3_t viewangles; @@ -306,22 +341,46 @@ typedef struct float forwardmove; float sidemove; float upmove; + + vec3_t cursor_screen; + vec3_t cursor_start; + vec3_t cursor_end; + vec3_t cursor_impact; + vec3_t cursor_normal; + vec_t cursor_fraction; + int cursor_entitynumber; + + double time; + double receivetime; + int buttons; + int impulse; + int sequence; + qboolean applied; // if false we're still accumulating a move } usercmd_t; -typedef struct +typedef struct lightstyle_s { int length; char map[MAX_STYLESTRING]; } lightstyle_t; -typedef struct +typedef struct scoreboard_s { char name[MAX_SCOREBOARDNAME]; int frags; int colors; // two 4 bit fields + // QW fields: + int qw_userid; + char qw_userinfo[MAX_USERINFO_STRING]; + float qw_entertime; + int qw_ping; + int qw_packetloss; + int qw_spectator; + char qw_team[8]; + char qw_skin[MAX_QPATH]; } scoreboard_t; -typedef struct +typedef struct cshift_s { int destcolor[3]; int percent; // 0-256 @@ -346,7 +405,7 @@ typedef struct #define MAX_DEMOS 8 #define MAX_DEMONAME 16 -typedef enum +typedef enum cactive_e { ca_dedicated, // a dedicated server with no ability to start a client ca_disconnected, // full screen console with no connection @@ -354,11 +413,21 @@ typedef enum } cactive_t; +typedef enum qw_downloadtype_e +{ + dl_none, + dl_single, + dl_skin, + dl_model, + dl_sound +} +qw_downloadtype_t; + // // the client_static_t structure is persistent through an arbitrary number // of server connections // -typedef struct +typedef struct client_static_s { cactive_t state; @@ -396,24 +465,81 @@ typedef struct double connect_nextsendtime; lhnetsocket_t *connect_mysocket; lhnetaddress_t connect_address; + // protocol version of the server we're connected to + // (kept outside client_state_t because it's used between levels) + protocolversion_t protocol; // connection information // 0 to SIGNONS int signon; // network connection netconn_t *netcon; - // writing buffer to send to server - sizebuf_t message; + + // quakeworld stuff below + + // value of "qport" cvar at time of connection + int qw_qport; + + // current file download buffer (only saved when file is completed) + char qw_downloadname[MAX_QPATH]; + unsigned char *qw_downloadmemory; + int qw_downloadmemorycursize; + int qw_downloadmemorymaxsize; + int qw_downloadnumber; + int qw_downloadpercent; + qw_downloadtype_t qw_downloadtype; + + // current file upload buffer (for uploading screenshots to server) + unsigned char *qw_uploaddata; + int qw_uploadsize; + int qw_uploadpos; + + // user infostring + // this normally contains the following keys in quakeworld: + // password spectator name team skin topcolor bottomcolor rate noaim msg *ver *ip + char userinfo[MAX_USERINFO_STRING]; } client_static_t; extern client_static_t cls; +typedef struct client_movementqueue_s +{ + double time; + float frametime; + int sequence; + float viewangles[3]; + float move[3]; + qboolean jump; + qboolean crouch; +} +client_movementqueue_t; + +//[515]: csqc +typedef struct +{ + qboolean drawworld; + qboolean drawenginesbar; + qboolean drawcrosshair; +}csqc_vidvars_t; + +typedef struct qw_usercmd_s +{ + vec3_t angles; + short forwardmove, sidemove, upmove; + unsigned char padding1[2]; + unsigned char msec; + unsigned char buttons; + unsigned char impulse; + unsigned char padding2; +} +qw_usercmd_t; + // // the client_state_t structure is wiped completely at every // server signon // -typedef struct +typedef struct client_state_s { // true if playing in a local game and no one else is connected int islocalgame; @@ -425,16 +551,18 @@ typedef struct // send a clc_nop periodically until connected float sendnoptime; - // last command sent to the server + // current input to send to the server usercmd_t cmd; // information for local display // health, etc int stats[MAX_CL_STATS]; - // inventory bit flags - int items; + // last known inventory bit flags, for blinking + int olditems; // cl.time of acquiring item, for blinking float item_gettime[32]; + // last known STAT_ACTIVEWEAPON + int activeweapon; // cl.time of changing STAT_ACTIVEWEAPON float weapontime; // use pain anim frame if cl.time < this @@ -450,20 +578,35 @@ typedef struct // the view is temporarily offset, and an angle reset commands at the start // of each level and after teleporting. - // during demo playback viewangles is lerped between these - vec3_t mviewangles[2]; - // either client controlled, or lerped from demo mviewangles - vec3_t viewangles; - + // mviewangles is read from demo + // viewangles is either client controlled or lerped from mviewangles + vec3_t mviewangles[2], viewangles; + // update by server, used by qc to do weapon recoil + vec3_t mpunchangle[2], punchangle; + // update by server, can be used by mods to kick view around + vec3_t mpunchvector[2], punchvector; // 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; + vec3_t mvelocity[2], velocity; + // update by server, can be used by mods for zooming + vec_t mviewzoom[2], viewzoom; + + // client movement simulation + // these fields are only updated by CL_ClientMovement (called by CL_SendMove after parsing each network packet) + qboolean movement; + // this is set true by svc_time parsing and causes a new movement to be + // queued for prediction purposes + qboolean movement_needupdate; + // indicates the queue has been updated and should be replayed + qboolean movement_replay; + // simulated data (this is valid even if cl.movement is false) + vec3_t movement_origin; + vec3_t movement_oldorigin; + vec3_t movement_velocity; + // queue of proposed moves + int movement_numqueue; + client_movementqueue_t movement_queue[64]; + int movesequence; + int servermovesequence; // pitch drifting vars float idealpitch; @@ -472,7 +615,12 @@ typedef struct float driftmove; double laststop; - float viewheight; +//[515]: added for csqc purposes + float sensitivityscale; + csqc_vidvars_t csqc_vidvars; //[515]: these parms must be set to true by default + qboolean csqc_wantsmousemove; + struct model_s *csqc_model_precache[MAX_MODELS]; + // local amount for smoothing stepups //float crouch; @@ -481,6 +629,11 @@ typedef struct qboolean onground; qboolean inwater; + // used by bob + qboolean oldonground; + double lastongroundtime; + double hitgroundtime; + // don't change view angle, full screen, etc int intermission; // latched at intermission start @@ -501,6 +654,10 @@ typedef struct struct model_s *model_precache[MAX_MODELS]; struct sfx_s *sound_precache[MAX_SOUNDS]; + // FIXME: this is a lot of memory to be keeping around, this really should be dynamically allocated and freed somehow + char model_name[MAX_MODELS][MAX_QPATH]; + char sound_name[MAX_SOUNDS][MAX_QPATH]; + // for display on solo scoreboard char levelname[40]; // cl_entitites[cl.viewentity] = player @@ -513,6 +670,19 @@ typedef struct // type of game (deathmatch, coop, singleplayer) int gametype; + // models and sounds used by engine code (particularly cl_parse.c) + model_t *model_bolt; + model_t *model_bolt2; + model_t *model_bolt3; + model_t *model_beam; + sfx_t *sfx_wizhit; + sfx_t *sfx_knighthit; + sfx_t *sfx_tink1; + sfx_t *sfx_ric1; + sfx_t *sfx_ric2; + sfx_t *sfx_ric3; + sfx_t *sfx_r_exp3; + // refresh related state // cl_entitites[0].model @@ -529,22 +699,66 @@ typedef struct // [cl.maxclients] scoreboard_t *scores; - // LordHavoc: sniping zoom, QC controlled - float viewzoom; - // for interpolation - float viewzoomold, viewzoomnew; + // entity database stuff + // latest received entity frame numbers +#define LATESTFRAMENUMS 3 + int latestframenums[LATESTFRAMENUMS]; + entityframe_database_t *entitydatabase; + entityframe4_database_t *entitydatabase4; + entityframeqw_database_t *entitydatabaseqw; - // protocol version of the server we're connected to - int protocol; + // quakeworld stuff - // entity database stuff - entity_database_t entitydatabase; - entity_database4_t *entitydatabase4; + // local copy of the server infostring + char qw_serverinfo[MAX_SERVERINFO_STRING]; + + // time of last qw "pings" command sent to server while showing scores + double last_ping_request; + + // used during connect + int qw_servercount; + + // updated from serverinfo + int qw_teamplay; + + // indicates whether the player is spectating + qboolean qw_spectator; + + // movement parameters for client prediction + float qw_movevars_gravity; + float qw_movevars_stopspeed; + float qw_movevars_maxspeed; // can change during play + float qw_movevars_spectatormaxspeed; + float qw_movevars_accelerate; + float qw_movevars_airaccelerate; + float qw_movevars_wateraccelerate; + float qw_movevars_friction; + float qw_movevars_waterfriction; + float qw_movevars_entgravity; // can change during play + + // models used by qw protocol + int qw_modelindex_spike; + int qw_modelindex_player; + int qw_modelindex_flag; + int qw_modelindex_s_explod; + + vec3_t qw_intermission_origin; + vec3_t qw_intermission_angles; + + // 255 is the most nails the QW protocol could send + int qw_num_nails; + vec_t qw_nails[255][6]; + + float qw_weaponkick; + + int qw_validsequence; + + qw_usercmd_t qw_moves[QW_UPDATE_BACKUP]; + + int qw_deltasequence[QW_UPDATE_BACKUP]; } client_state_t; -extern mempool_t *cl_scores_mempool; - // // cvars // @@ -552,6 +766,11 @@ extern cvar_t cl_name; extern cvar_t cl_color; extern cvar_t cl_rate; extern cvar_t cl_pmodel; +extern cvar_t cl_playermodel; +extern cvar_t cl_playerskin; + +extern cvar_t rcon_password; +extern cvar_t rcon_address; extern cvar_t cl_upspeed; extern cvar_t cl_forwardspeed; @@ -567,6 +786,9 @@ extern cvar_t cl_anglespeedkey; extern cvar_t cl_autofire; +extern cvar_t csqc_progname; //[515]: csqc crc check and right csprogs name according to progs.dat +extern cvar_t csqc_progcrc; + extern cvar_t cl_shownet; extern cvar_t cl_nolerp; @@ -584,30 +806,58 @@ extern cvar_t m_side; extern cvar_t r_draweffects; -extern cvar_t cl_explosions; +extern cvar_t cl_explosions_alpha_start; +extern cvar_t cl_explosions_alpha_end; +extern cvar_t cl_explosions_size_start; +extern cvar_t cl_explosions_size_end; +extern cvar_t cl_explosions_lifetime; extern cvar_t cl_stainmaps; +extern cvar_t cl_stainmaps_clearonload; -// 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 cvar_t cl_prydoncursor; + +extern vec3_t cl_playerstandmins; +extern vec3_t cl_playerstandmaxs; +extern vec3_t cl_playercrouchmins; +extern vec3_t cl_playercrouchmaxs; + +extern mempool_t *cl_mempool; + +extern int cl_max_entities; +extern int cl_max_csqcentities; +extern int cl_max_static_entities; +extern int cl_max_temp_entities; +extern int cl_max_effects; +extern int cl_max_beams; +extern int cl_max_dlights; +extern int cl_max_lightstyle; +extern int cl_max_brushmodel_entities; +extern int cl_activedlights; +extern int cl_activeeffects; +extern int cl_activebeams; extern entity_t *cl_entities; -extern qbyte *cl_entities_active; +extern entity_t *cl_csqcentities; //[515]: csqc +extern unsigned char *cl_entities_active; +extern unsigned char *cl_csqcentities_active; //[515]: csqc 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 int *cl_brushmodel_entities; +// these are updated by CL_ClearState +extern int cl_num_entities; +extern int cl_num_csqcentities; //[515]: csqc +extern int cl_num_static_entities; +extern int cl_num_temp_entities; +extern int cl_num_brushmodel_entities; extern client_state_t cl; -extern void CL_AllocDlight (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); -extern void CL_DecayLights (void); +extern void CL_AllocDlight (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); //============================================================================= @@ -615,6 +865,7 @@ extern void CL_DecayLights (void); // cl_main // +void CL_Shutdown (void); void CL_Init (void); void CL_EstablishConnection(const char *host); @@ -631,7 +882,7 @@ extern cvar_t cl_beams_lightatend; // // cl_input // -typedef struct +typedef struct kbutton_s { int down[2]; // key nums holding it down int state; // low bit is down state @@ -643,9 +894,10 @@ extern kbutton_t in_strafe; extern kbutton_t in_speed; void CL_InitInput (void); -void CL_SendCmd (usercmd_t *cmd); -void CL_SendMove (usercmd_t *cmd); +void CL_SendMove (void); +void CL_ValidateState(entity_state_t *s); +void CL_MoveLerpEntityStates(entity_t *ent); void CL_LerpUpdate(entity_t *e); void CL_ParseTEnt (void); void CL_RelinkBeams (void); @@ -656,15 +908,18 @@ entity_t *CL_NewTempEntity (void); void CL_Effect(vec3_t org, int modelindex, int startframe, int framecount, float framerate); void CL_ClearState (void); +void CL_ExpandEntities(int num); int CL_ReadFromServer (void); -void CL_WriteToServer (usercmd_t *cmd); -void CL_BaseMove (usercmd_t *cmd); +void CL_WriteToServer (void); +void CL_Move (void); +extern qboolean cl_ignoremousemove; float CL_KeyState (kbutton_t *key); const char *Key_KeynumToString (int keynum); +int Key_StringToKeynum (const char *str); // // cl_demo.c @@ -683,8 +938,12 @@ void CL_TimeDemo_f(void); // cl_parse.c // void CL_Parse_Init(void); +void CL_Parse_Shutdown(void); void CL_ParseServerMessage(void); void CL_Parse_DumpPacket(void); +void CL_Parse_ErrorCleanUp(void); +void QW_CL_StartUpload(unsigned char *data, int size); +extern cvar_t qport; // // view @@ -697,24 +956,42 @@ float V_CalcRoll (vec3_t angles, vec3_t velocity); void V_UpdateBlends (void); void V_ParseDamage (void); - -// -// cl_tent -// -void CL_InitTEnts (void); - // // cl_part // +extern cvar_t cl_particles; +extern cvar_t cl_particles_quality; +extern cvar_t cl_particles_size; +extern cvar_t cl_particles_quake; +extern cvar_t cl_particles_bloodshowers; +extern cvar_t cl_particles_blood; +extern cvar_t cl_particles_blood_alpha; +extern cvar_t cl_particles_blood_bloodhack; +extern cvar_t cl_particles_bulletimpacts; +extern cvar_t cl_particles_explosions_bubbles; +extern cvar_t cl_particles_explosions_smoke; +extern cvar_t cl_particles_explosions_sparks; +extern cvar_t cl_particles_explosions_shell; +extern cvar_t cl_particles_smoke; +extern cvar_t cl_particles_smoke_alpha; +extern cvar_t cl_particles_smoke_alphafade; +extern cvar_t cl_particles_sparks; +extern cvar_t cl_particles_bubbles; +extern cvar_t cl_decals; +extern cvar_t cl_decals_time; +extern cvar_t cl_decals_fadetime; + void CL_Particles_Clear(void); void CL_Particles_Init(void); +void CL_Particles_Shutdown(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_RocketTrail (vec3_t start, vec3_t end, int type, int color, entity_t *ent); +void CL_SparkShower (vec3_t org, vec3_t dir, int count, vec_t gravityscale, vec_t radius); +void CL_Smoke (vec3_t org, vec3_t dir, int count, vec_t radius); +void CL_BulletMark (vec3_t org); 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); @@ -738,31 +1015,62 @@ void R_NewExplosion(vec3_t org); #include "cl_screen.h" -typedef struct +#define NUMCROSSHAIRS 6 +extern cachepic_t *r_crosshairs[NUMCROSSHAIRS]; + +typedef struct refdef_s { // area to render in int x, y, width, height; - float fov_x, fov_y; + float frustum_x, frustum_y; + + // these are set for water warping before + // frustum_x/frustum_y are calculated + float frustumscale_x, frustumscale_y; // view transform matrix4x4_t viewentitymatrix; + // which color components to allow (for anaglyph glasses) + int colormask[4]; + // fullscreen color blend float viewblend[4]; + // whether to call S_ExtraUpdate during render to reduce sound chop + qboolean extraupdate; + + // client gameworld time for rendering time based effects + double time; + + // the world + entity_render_t *worldentity; + + // same as worldentity->model + model_t *worldmodel; + + // renderable entities (excluding world) entity_render_t **entities; int numentities; int maxentities; - qbyte *drawqueue; + // renderable dynamic lights + dlight_t *lights[MAX_DLIGHTS]; + int numlights; + + // 8.8bit fixed point intensities for light styles + // controls intensity of dynamic lights and lightmap layers + unsigned short lightstylevalue[256]; // 8.8 fraction of base light value + + // 2D art drawing queue + // TODO: get rid of this + unsigned char *drawqueue; int drawqueuesize; int maxdrawqueuesize; } refdef_t; -refdef_t r_refdef; - -extern mempool_t *cl_refdef_mempool; +extern refdef_t r_refdef; #include "cgamevm.h"