X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=client.h;h=28a0c65c51e960925f42289bee06c996772a990d;hb=4b9fb5c623dc4ebd8e10213af3edbcaea2e62fb7;hp=a52d83e5291708bfa9db096a47714331cb6e2ed6;hpb=eb35bb76a4704ec05030b29548b2691ca3dee6d5;p=xonotic%2Fdarkplaces.git diff --git a/client.h b/client.h index a52d83e5..28a0c65c 100644 --- a/client.h +++ b/client.h @@ -31,6 +31,10 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. // max lights shining on one entity #define MAXENTLIGHTS 128 +// flags for rtlight rendering +#define LIGHTFLAG_NORMALMODE 1 +#define LIGHTFLAG_REALTIMEMODE 2 + extern int cl_max_entities; extern int cl_max_static_entities; extern int cl_max_temp_entities; @@ -53,29 +57,161 @@ typedef struct effect_s } cl_effect_t; -typedef struct +typedef struct beam_s { int entity; + // draw this as lightning polygons, or a model? + int lightning; struct model_s *model; float endtime; vec3_t start, end; + // if this beam is owned by an entity, this is the beam start relative to + // that entity's matrix for per frame start updates + vec3_t relativestart; + vec3_t relativeend; + // indicates whether relativestart is valid + int relativestartvalid; } beam_t; -typedef struct +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 + + // 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; + // 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; + // 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; + // culling + vec3_t cullmins; + vec3_t cullmaxs; + // culling + //vec_t cullradius; + // squared cullradius + //vec_t cullradius2; + + // lightmap renderer stuff (remove someday!) + // the size of the light + vec_t lightmap_cullradius; + // the size of the light, squared + vec_t lightmap_cullradius2; + // the brightness of the light + vec3_t lightmap_light; + // to avoid sudden brightness change at cullradius, subtract this + vec_t lightmap_subtract; + + // static light info + // true if this light should be compiled as a static light + int isstatic; + // true if this is a compiled world light, cleared if the light changes + int compiled; + // premade shadow volumes to render for world entity + shadowmesh_t *static_meshchain_shadow; + // used for visibility testing (more exact than bbox) + int static_numleafs; + int static_numleafpvsbytes; + int *static_leaflist; + qbyte *static_leafpvs; + // surfaces seen by light + int static_numsurfaces; + int *static_surfacelist; +} +rtlight_t; + +typedef struct dlight_s { + // destroy light after this time + // (dlight only) + vec_t die; + // the entity that owns this light (can be NULL) + // (dlight only) + struct entity_render_s *ent; // location - vec3_t origin; - // stop lighting after this time - float die; + // (worldlight: saved to .rtlights file) + vec3_t origin; + // worldlight orientation + // (worldlight only) + // (worldlight: saved to .rtlights file) + vec3_t angles; + // dlight orientation/scaling/location + // (dlight only) + matrix4x4_t matrix; // color of light - vec3_t color; + // (worldlight: saved to .rtlights file) + vec3_t color; + // cubemap number to use on this light + // (dlight only) + int cubemapnum; + // cubemap name to use on this light + // (worldlight only) + // (worldlight: saved to .rtlights file) + char cubemapname[64]; + // make light flash while selected + // (worldlight only) + int selected; // brightness (not really radius anymore) - float radius; - // drop this each second - float decay; - // the entity that owns this light (can be NULL) - struct entity_render_s *ent; + // (worldlight: saved to .rtlights file) + vec_t radius; + // drop radius this much each second + // (dlight only) + vec_t decay; + // light style which controls intensity of this light + // (worldlight: saved to .rtlights file) + int style; + // cast shadows + // (worldlight: saved to .rtlights file) + int shadow; + // 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) + rtlight_t rtlight; } dlight_t; @@ -86,8 +222,8 @@ typedef struct frameblend_s } 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. +// LordHavoc: this struct is intended for the renderer but some fields are +// used by the client. typedef struct entity_render_s { // location @@ -107,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 @@ -116,14 +255,17 @@ typedef struct entity_render_s // render flags int flags; - // these are copied from the persistent data + // colormod tinting of models + float colormod[3]; + + // interpolated animation // 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; + float framelerp; // time frame1 began playing (for framegroup animations) double frame1time; // time frame2 began playing (for framegroup animations) @@ -149,13 +291,12 @@ entity_render_t; typedef struct entity_persistent_s { - // particles + int linkframe; - // trail rendering vec3_t trail_origin; - float trail_time; - // effects + // particle trail + float trail_time; // muzzleflash fading float muzzleflash; @@ -171,21 +312,6 @@ typedef struct entity_persistent_s 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; @@ -206,7 +332,7 @@ typedef struct entity_s } entity_t; -typedef struct +typedef struct usercmd_s { vec3_t viewangles; @@ -214,23 +340,36 @@ 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; } 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]; - float entertime; int frags; int colors; // two 4 bit fields } scoreboard_t; -typedef struct +typedef struct cshift_s { int destcolor[3]; int percent; // 0-256 @@ -240,7 +379,8 @@ typedef struct #define CSHIFT_DAMAGE 1 #define CSHIFT_BONUS 2 #define CSHIFT_POWERUP 3 -#define NUM_CSHIFTS 4 +#define CSHIFT_VCSHIFT 4 +#define NUM_CSHIFTS 5 #define NAME_LENGTH 64 @@ -266,7 +406,7 @@ cactive_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; @@ -275,6 +415,8 @@ typedef struct int demonum; // list of demos in loop char demos[MAX_DEMOS][MAX_DEMONAME]; + // the actively playing demo (set by CL_PlayDemo_f) + char demoname[64]; // demo recording info must be here, because record is started before // entering a map (and clearing client_state_t) @@ -283,35 +425,60 @@ typedef struct qboolean timedemo; // -1 = use normal cd track int forcetrack; - QFile *demofile; + qfile_t *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: for measuring maxfps + double td_minframetime; + // LordHavoc: for measuring minfps + double td_maxframetime; // LordHavoc: pausedemo qboolean demopaused; + qboolean connect_trying; + int connect_remainingtries; + double connect_nextsendtime; + lhnetsocket_t *connect_mysocket; + lhnetaddress_t connect_address; // connection information // 0 to SIGNONS int signon; - // network socket - struct qsocket_s *netcon; + // network connection + netconn_t *netcon; // writing buffer to send to server sizebuf_t message; + qbyte message_buf[1024]; } 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; + // // 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; + // 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; @@ -319,16 +486,20 @@ 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 float faceanimtime; @@ -342,20 +513,32 @@ 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; + // 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; @@ -364,7 +547,6 @@ typedef struct float driftmove; double laststop; - float viewheight; // local amount for smoothing stepups //float crouch; @@ -373,6 +555,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 @@ -405,6 +592,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 @@ -421,27 +621,27 @@ typedef struct // [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; + // protocol version of the server we're connected to + protocolversion_t protocol; // entity database stuff - vec3_t viewentoriginold, viewentoriginnew; - entity_database_t entitydatabase; + // latest received entity frame numbers +#define LATESTFRAMENUMS 3 + int latestframenums[LATESTFRAMENUMS]; + entityframe_database_t *entitydatabase; + entityframe4_database_t *entitydatabase4; } client_state_t; -extern mempool_t *cl_scores_mempool; - // // cvars // 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 cl_upspeed; extern cvar_t cl_forwardspeed; @@ -474,8 +674,20 @@ 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; + +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; // these are updated by CL_ClearState extern int cl_num_entities; @@ -483,11 +695,12 @@ extern int cl_num_static_entities; extern int cl_num_temp_entities; extern int cl_num_brushmodel_entities; +extern mempool_t *cl_mempool; 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 int *cl_brushmodel_entities; extern cl_effect_t *cl_effects; extern beam_t *cl_beams; extern dlight_t *cl_dlights; @@ -496,8 +709,7 @@ 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); +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); //============================================================================= @@ -505,19 +717,24 @@ extern void CL_DecayLights (void); // cl_main // +void CL_Shutdown (void); void CL_Init (void); -void CL_EstablishConnection (char *host); +void CL_EstablishConnection(const char *host); void CL_Disconnect (void); void CL_Disconnect_f (void); void CL_BoundingBoxForEntity(entity_render_t *ent); +extern cvar_t cl_beams_polygons; +extern cvar_t cl_beams_relative; +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 @@ -530,8 +747,10 @@ extern kbutton_t in_speed; void CL_InitInput (void); void CL_SendCmd (void); -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); @@ -542,33 +761,39 @@ 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); -char *Key_KeynumToString (int keynum); +const char *Key_KeynumToString (int keynum); +int Key_StringToKeynum (const char *str); // // cl_demo.c // -void CL_StopPlayback (void); -int CL_GetMessage (void); +void CL_StopPlayback(void); +void CL_ReadDemoMessage(void); +void CL_WriteDemoMessage(void); -void CL_NextDemo (void); -void CL_Stop_f (void); -void CL_Record_f (void); -void CL_PlayDemo_f (void); -void CL_TimeDemo_f (void); +void CL_NextDemo(void); +void CL_Stop_f(void); +void CL_Record_f(void); +void CL_PlayDemo_f(void); +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); // // view @@ -581,24 +806,41 @@ 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_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); +void CL_Smoke (vec3_t org, vec3_t dir, int count); +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); @@ -613,45 +855,70 @@ 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_BeamParticle (const vec3_t start, const vec3_t end, vec_t radius, float red, float green, float blue, float alpha, float lifetime); +void CL_Tei_Smoke(const vec3_t pos, const vec3_t dir, int count); +void CL_Tei_PlasmaHit(const vec3_t pos, const vec3_t dir, int count); void CL_MoveParticles(void); void R_MoveExplosions(void); void R_NewExplosion(vec3_t org); #include "cl_screen.h" -typedef struct +typedef struct refdef_s { // area to render in int x, y, width, height; float fov_x, fov_y; - // view point - vec3_t vieworg; - vec3_t viewangles; + // these are set for water warping before + // fov_x/fov_y are calculated + float fovscale_x, fovscale_y; + + // view transform + matrix4x4_t viewentitymatrix; + + // which color components to allow (for anaglyph glasses) + int colormask[4]; // fullscreen color blend float viewblend[4]; - // weapon model - entity_render_t viewent; + // 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; + // 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 qbyte *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" -void Host_PerformSpawnServerAndLoadGame(void); - #endif