X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=client.h;h=28c047d626cf1f56587b5bb76b51cec245bde1e4;hp=297b5d6b8b3152f72f6f467b524aa575ee836a8d;hb=8ebb89488cfbf28c6d0234dbb6fec83c59e29e1e;hpb=e3d61760f1dec49cb93eb98882cd2a7948ac5362 diff --git a/client.h b/client.h index 297b5d6b..28c047d6 100644 --- a/client.h +++ b/client.h @@ -69,6 +69,8 @@ typedef struct rtlight_s // note that the world to light matrices are inversely scaled (divided) by lightradius // core properties + // matrix for transforming light filter coordinates to world coordinates + matrix4x4_t matrix_lighttoworld; // matrix for transforming world coordinates to light filter coordinates matrix4x4_t matrix_worldtolight; // typically 1 1 1, can be lower (dim) or higher (overbright) @@ -126,6 +128,19 @@ typedef struct rtlight_s // surfaces seen by light int static_numsurfaces; int *static_surfacelist; + // flag bits indicating which triangles of the world model should cast + // shadows, and which ones should be lit + // + // this avoids redundantly scanning the triangles in each surface twice + // for whether they should cast shadows, once in culling and once in the + // actual shadowmarklist production. + int static_numshadowtrispvsbytes; + unsigned char *static_shadowtrispvs; + // this allows the lighting batch code to skip backfaces andother culled + // triangles not relevant for lighting + // (important on big surfaces such as terrain) + int static_numlighttrispvsbytes; + unsigned char *static_lighttrispvs; } rtlight_t; @@ -211,6 +226,12 @@ frameblend_t; // LordHavoc: this struct is intended for the renderer but some fields are // used by the client. +// +// The renderer should not rely on any changes to this struct to be persistent +// across multiple frames because temp entities are wiped every frame, but it +// is acceptable to cache things in this struct that are not critical. +// +// For example the r_cullentities_trace code does such caching. typedef struct entity_render_s { // location @@ -228,15 +249,15 @@ typedef struct entity_render_s // NULL = no model model_t *model; - // current uninterpolated animation frame (for things which do not use interpolation) - int frame; - // entity shirt and pants colors (-1 if not colormapped) - int colormap; - // literal colors for renderer + // number of the entity represents, or 0 for non-network entities + int entitynumber; + // literal colormap colors for renderer, if both are 0 0 0 it is not colormapped vec3_t colormap_pantscolor; vec3_t colormap_shirtcolor; // light, particles, etc int effects; + // qw CTF flags and other internal-use-only effect bits + int internaleffects; // for Alias models int skinnum; // render flags @@ -265,10 +286,14 @@ typedef struct entity_render_s // 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]; - // current lighting from map + // current lighting from map (updated ONLY by client code, not renderer) vec3_t modellight_ambient; vec3_t modellight_diffuse; // q3bsp vec3_t modellight_lightdir; // q3bsp + + // FIELDS UPDATED BY RENDERER: + // last time visible during trace culling + double last_trace_visibility; } entity_render_t; @@ -278,6 +303,7 @@ typedef struct entity_persistent_s // particle trail float trail_time; + qboolean trail_allowed; // set to false by teleports, true by update code, prevents bad lerps // muzzleflash fading float muzzleflash; @@ -337,6 +363,7 @@ typedef struct usercmd_s int impulse; int sequence; qboolean applied; // if false we're still accumulating a move + qboolean predicted; // if true the sequence should be sent as 0 } usercmd_t; typedef struct lightstyle_s @@ -415,9 +442,17 @@ typedef struct capturevideostate_s double starttime; double framerate; // for AVI saving some values have to be written after capture ends + fs_offset_t videofile_firstchunkframes_offset; fs_offset_t videofile_totalframes_offset1; fs_offset_t videofile_totalframes_offset2; fs_offset_t videofile_totalsampleframes_offset; + int videofile_ix_master_audio_inuse; + fs_offset_t videofile_ix_master_audio_inuse_offset; + fs_offset_t videofile_ix_master_audio_start_offset; + int videofile_ix_master_video_inuse; + fs_offset_t videofile_ix_master_video_inuse_offset; + fs_offset_t videofile_ix_master_video_start_offset; + fs_offset_t videofile_ix_movistart; qfile_t *videofile; qboolean active; qboolean realtime; @@ -426,7 +461,8 @@ typedef struct capturevideostate_s int soundrate; int frame; int soundsampleframe; // for AVI saving - unsigned char *buffer; + unsigned char *screenbuffer; + unsigned char *outbuffer; sizebuf_t riffbuffer; unsigned char riffbufferdata[128]; // note: riffindex buffer has an allocated ->data member, not static like most! @@ -436,6 +472,7 @@ typedef struct capturevideostate_s short rgbtoyuvscaletable[3][3][256]; unsigned char yuvnormalizetable[3][256]; char basename[64]; + int width, height; } capturevideostate_t; @@ -475,12 +512,9 @@ typedef struct client_static_s // -1 = use normal cd track int forcetrack; 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; + int td_frames; // total frames parsed double td_onesecondnexttime; double td_onesecondframes; double td_onesecondminframes; @@ -509,6 +543,10 @@ typedef struct client_static_s // (note: qw_download variables are also used) cl_downloadack_t dp_downloadack[CL_MAX_DOWNLOADACKS]; + // input sequence numbers are not reset on level change, only connect + int movesequence; + int servermovesequence; + // quakeworld stuff below // value of "qport" cvar at time of connection @@ -556,6 +594,7 @@ typedef struct client_movementqueue_s float move[3]; qboolean jump; qboolean crouch; + qboolean canjump; } client_movementqueue_t; @@ -594,30 +633,46 @@ particletype_t; typedef enum { - 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 + 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 } ptype_t; +typedef struct decal_s +{ + unsigned short typeindex; + unsigned short texnum; + vec3_t org; + vec3_t normal; + float size; + float alpha; // 0-255 + float time2; // used for snow fluttering and decal fade + unsigned char color[4]; + unsigned int owner; // decal stuck to this entity + model_t *ownermodel; // model the decal is stuck to (used to make sure the entity is still alive) + vec3_t relativeorigin; // decal at this location in entity's coordinate space + vec3_t relativenormal; // decal oriented this way relative to entity's coordinate space +} +decal_t; + typedef struct particle_s { - particletype_t *type; - int texnum; - vec3_t org; - vec3_t vel; // velocity of particle, or orientation of decal, or end point of beam - float size; - float sizeincrease; // rate of size change per second - float alpha; // 0-255 - float alphafade; // how much alpha reduces per second - float time2; // used for snow fluttering and decal fade - 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) - float gravity; // how much gravity affects this particle (1.0 = normal gravity, 0.0 = none) - float airfriction; // how much air friction affects this object (objects with a low mass/size ratio tend to get more air friction) - float liquidfriction; // how much liquid friction affects this object (objects with a low mass/size ratio tend to get more liquid friction) - unsigned char color[4]; - unsigned int owner; // decal stuck to this entity - model_t *ownermodel; // model the decal is stuck to (used to make sure the entity is still alive) - vec3_t relativeorigin; // decal at this location in entity's coordinate space - vec3_t relativedirection; // decal oriented this way relative to entity's coordinate space + unsigned short typeindex; + unsigned short texnum; + vec3_t org; + vec3_t vel; // velocity of particle, or orientation of decal, or end point of beam + float size; + float sizeincrease; // rate of size change per second + float alpha; // 0-255 + float alphafade; // how much alpha reduces per second + float time2; // used for snow fluttering and decal fade + 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) + float gravity; // how much gravity affects this particle (1.0 = normal gravity, 0.0 = none) + float airfriction; // how much air friction affects this object (objects with a low mass/size ratio tend to get more air friction) + float liquidfriction; // how much liquid friction affects this object (objects with a low mass/size ratio tend to get more liquid friction) + unsigned char color[4]; + float delayedcollisions; // time that p->bounce becomes active + float delayedspawn; // time that particle appears and begins moving + float die; // time when this particle should be removed, regardless of alpha } particle_t; @@ -631,6 +686,24 @@ typedef enum cl_parsingtextmode_e } cl_parsingtextmode_t; +typedef struct cl_locnode_s +{ + struct cl_locnode_s *next; + char *name; + vec3_t mins, maxs; +} +cl_locnode_t; + +typedef struct showlmp_s +{ + qboolean isactive; + float x; + float y; + char label[32]; + char pic[128]; +} +showlmp_t; + // // the client_state_t structure is wiped completely at every // server signon @@ -651,6 +724,7 @@ typedef struct client_state_s // information for local display // health, etc int stats[MAX_CL_STATS]; + float *statsf; // points to stats[] array // last known inventory bit flags, for blinking int olditems; // cl.time of acquiring item, for blinking @@ -662,7 +736,8 @@ typedef struct client_state_s // use pain anim frame if cl.time < this float faceanimtime; // for stair smoothing - float stairoffset; + float stairsmoothz; + double stairsmoothtime; // color shifts for damage, powerups cshift_t cshifts[NUM_CSHIFTS]; @@ -696,6 +771,8 @@ typedef struct client_state_s // these fields are only updated by CL_ClientMovement (called by CL_SendMove after parsing each network packet) // set by CL_ClientMovement_Replay functions qboolean movement_predicted; + // if true the CL_ClientMovement_Replay function will update origin, etc + qboolean movement_replay; // this is set true by svc_time parsing and causes a new movement to be // queued for prediction purposes qboolean movement_needupdate; @@ -708,8 +785,6 @@ typedef struct client_state_s // queue of proposed moves int movement_numqueue; client_movementqueue_t movement_queue[256]; - int movesequence; - int servermovesequence; // whether the replay should allow a jump at the first sequence qboolean movement_replay_canjump; @@ -774,6 +849,11 @@ typedef struct client_state_s int viewentity; // the real player entity (normally same as viewentity, // different than viewentity if mod uses chasecam or other tricks) + int realplayerentity; + // this is updated to match cl.viewentity whenever it is in the clients + // range, basically this is used in preference to cl.realplayerentity for + // most purposes because when spectating another player it should show + // their information rather than yours int playerentity; // max players that can be in this game int maxclients; @@ -792,6 +872,8 @@ typedef struct client_state_s sfx_t *sfx_ric2; sfx_t *sfx_ric3; sfx_t *sfx_r_exp3; + // indicates that the file "sound/misc/talk2.wav" was found (for use by team chat messages) + qboolean foundtalk2wav; // refresh related state @@ -846,6 +928,8 @@ typedef struct client_state_s int max_lightstyle; int max_brushmodel_entities; int max_particles; + int max_decals; + int max_showlmps; entity_t *entities; unsigned char *entities_active; @@ -857,6 +941,8 @@ typedef struct client_state_s lightstyle_t *lightstyle; int *brushmodel_entities; particle_t *particles; + decal_t *decals; + showlmp_t *showlmps; int num_entities; int num_static_entities; @@ -866,8 +952,11 @@ typedef struct client_state_s int num_beams; int num_dlights; int num_particles; + int num_decals; + int num_showlmps; int free_particle; + int free_decal; // cl_serverextension_download feature int loadmodel_current; @@ -877,6 +966,8 @@ typedef struct client_state_s int downloadsound_current; int loadsound_total; qboolean downloadcsqc; + qboolean loadcsqc; + qboolean loadbegun; qboolean loadfinished; // quakeworld stuff @@ -894,20 +985,29 @@ typedef struct client_state_s int qw_teamplay; // unused: indicates whether the player is spectating - // use cl.scores[cl.playerentity].qw_spectator instead + // use cl.scores[cl.playerentity-1].qw_spectator instead //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 + float movevars_wallfriction; + float movevars_waterfriction; + float movevars_friction; + float movevars_ticrate; + float movevars_timescale; + float movevars_gravity; + float movevars_stopspeed; + float movevars_maxspeed; + float movevars_spectatormaxspeed; + float movevars_accelerate; + float movevars_airaccelerate; + float movevars_wateraccelerate; + float movevars_entgravity; + float movevars_jumpvelocity; + float movevars_edgefriction; + float movevars_maxairspeed; + float movevars_stepheight; + float movevars_airaccel_qw; + float movevars_airaccel_sideways_friction; // models used by qw protocol int qw_modelindex_spike; @@ -929,9 +1029,28 @@ typedef struct client_state_s int qw_deltasequence[QW_UPDATE_BACKUP]; // csqc stuff: + // server entity number corresponding to a clientside entity + unsigned short csqc_server2csqcentitynumber[MAX_EDICTS]; + qboolean csqc_loaded; + vec3_t csqc_origin; + vec3_t csqc_angles; + qboolean csqc_usecsqclistener; + matrix4x4_t csqc_listenermatrix; + char csqc_printtextbuf[MAX_INPUTLINE]; // collision culling data world_t world; + + // loc file stuff (points and boxes describing locations in the level) + cl_locnode_t *locnodes; + // this is updated to cl.movement_origin whenever health is < 1 + // used by %d print in say/say_team messages if cl_locs_enable is on + vec3_t lastdeathorigin; + + // processing buffer used by R_BuildLightMap, reallocated as needed, + // freed on each level change + size_t buildlightmapmemorysize; + unsigned char *buildlightmapmemory; } client_state_t; @@ -964,7 +1083,9 @@ extern cvar_t cl_autofire; extern cvar_t cl_shownet; extern cvar_t cl_nolerp; -extern cvar_t cl_nettimesyncmode; +extern cvar_t cl_nettimesyncfactor; +extern cvar_t cl_nettimesyncboundmode; +extern cvar_t cl_nettimesyncboundtolerance; extern cvar_t cl_pitchdriftspeed; extern cvar_t lookspring; @@ -993,10 +1114,15 @@ extern cvar_t cl_stainmaps_clearonload; extern cvar_t cl_prydoncursor; +extern cvar_t cl_locs_enable; + extern client_state_t cl; 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); +cl_locnode_t *CL_Locs_FindNearest(const vec3_t point); +void CL_Locs_FindLocationName(char *buffer, size_t buffersize, vec3_t point); + //============================================================================= // @@ -1012,7 +1138,8 @@ void CL_Disconnect (void); void CL_Disconnect_f (void); void CL_UpdateRenderEntity(entity_render_t *ent); -void CL_UpdateEntities(void); +void CL_SetEntityColormapColors(entity_render_t *ent, int colormap); +void CL_UpdateViewEntities(void); // // cl_input @@ -1038,6 +1165,7 @@ void CL_ParseTEnt (void); void CL_NewBeam (int ent, vec3_t start, vec3_t end, model_t *m, int lightning); void CL_RelinkBeams (void); void CL_Beam_CalculatePositions (const beam_t *b, vec3_t start, vec3_t end); +void CL_ClientMovement_Replay(void); void CL_ClearTempEntities (void); entity_t *CL_NewTempEntity (void); @@ -1049,7 +1177,7 @@ void CL_ExpandEntities(int num); void CL_SetInfo(const char *key, const char *value, qboolean send, qboolean allowstarkey, qboolean allowmodel, qboolean quiet); -int CL_ReadFromServer (void); +void CL_UpdateWorld (void); void CL_WriteToServer (void); void CL_Input (void); extern qboolean cl_ignoremousemove; @@ -1064,7 +1192,7 @@ int Key_StringToKeynum (const char *str); // void CL_StopPlayback(void); void CL_ReadDemoMessage(void); -void CL_WriteDemoMessage(void); +void CL_WriteDemoMessage(sizebuf_t *mesage); void CL_NextDemo(void); void CL_Stop_f(void); @@ -1106,10 +1234,10 @@ 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_rain; +extern cvar_t cl_particles_snow; extern cvar_t cl_particles_smoke; extern cvar_t cl_particles_smoke_alpha; extern cvar_t cl_particles_smoke_alphafade; @@ -1175,6 +1303,7 @@ void CL_ParticleRain (const vec3_t mins, const vec3_t maxs, const vec3_t dir, in void CL_EntityParticles (const entity_t *ent); void CL_ParticleExplosion (const vec3_t org); void CL_ParticleExplosion2 (const vec3_t org, int colorStart, int colorLength); +void CL_MoveDecals(void); void CL_MoveParticles(void); void R_MoveExplosions(void); void R_NewExplosion(const vec3_t org); @@ -1187,12 +1316,9 @@ void Debug_PolygonEnd(void); extern qboolean sb_showscores; -#define NUMCROSSHAIRS 32 -extern cachepic_t *r_crosshairs[NUMCROSSHAIRS+1]; - -#define FOGTABLEWIDTH 1024 -extern int fogtableindex; -#define VERTEXFOGTABLE(dist) (fogtableindex = (int)((dist) * r_refdef.fogtabledistmultiplier), r_refdef.fogtable[bound(0, fogtableindex, FOGTABLEWIDTH - 1)]) +float FogPoint_World(const vec3_t p); +float FogPoint_Model(const vec3_t p); +float FogForDistance(vec_t dist); typedef struct r_refdef_stats_s { @@ -1201,7 +1327,12 @@ typedef struct r_refdef_stats_s int entities_triangles; int world_leafs; int world_portals; + int world_surfaces; + int world_triangles; + int lightmapupdates; + int lightmapupdatepixels; int particles; + int decals; int meshes; int meshes_elements; int lights; @@ -1256,19 +1387,26 @@ typedef struct r_refdef_s rtlight_t lights[MAX_DLIGHTS]; int numlights; + // intensities for light styles right now, controls rtlights + float rtlightstylevalue[256]; // float fraction of base light value // 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 + // controls intensity lightmap layers + unsigned short lightstylevalue[256]; // 8.8 fraction of base light value vec3_t fogcolor; vec_t fogrange; vec_t fograngerecip; - vec_t fogtabledistmultiplier; - float fogtable[FOGTABLEWIDTH]; + vec_t fogmasktabledistmultiplier; +#define FOGMASKTABLEWIDTH 1024 + float fogmasktable[FOGMASKTABLEWIDTH]; + float fogmasktable_start, fogmasktable_alpha, fogmasktable_range, fogmasktable_density; float fog_density; float fog_red; float fog_green; float fog_blue; + float fog_alpha; + float fog_start; + float fog_end; qboolean fogenabled; qboolean oldgl_fogenable; @@ -1308,14 +1446,22 @@ typedef struct r_view_s // (as long as R_View_Update is called) // eye position information - matrix4x4_t matrix; + matrix4x4_t matrix, inverse_matrix; vec3_t origin; vec3_t forward; vec3_t left; vec3_t right; vec3_t up; - mplane_t frustum[5]; + int numfrustumplanes; + mplane_t frustum[6]; + qboolean useclipplane; + qboolean usecustompvs; // uses r_viewcache.pvsbits as-is rather than computing it + mplane_t clipplane; float frustum_x, frustum_y; + vec3_t frustumcorner[4]; + // if turned off it renders an ortho view + int useperspective; + float ortho_x, ortho_y; // screen area to render in int x; @@ -1330,6 +1476,18 @@ typedef struct r_view_s // global RGB color multiplier for rendering, this is required by HDR float colorscale; + + // whether to call R_ClearScreen before rendering stuff + qboolean clear; + + // whether to draw r_showtris and such, this is only true for the main + // view render, all secondary renders (HDR, mirrors, portals, cameras, + // distortion effects, etc) omit such debugging information + qboolean showdebug; + + // these define which values to use in GL_CullFace calls to request frontface or backface culling + int cullface_front; + int cullface_back; } r_view_t; @@ -1343,11 +1501,11 @@ typedef struct r_viewcache_s // flag arrays used for visibility checking on world model // (all other entities have no per-surface/per-leaf visibility checks) // TODO: dynamic resize according to r_refdef.worldmodel->brush.num_clusters - unsigned char world_pvsbits[(32768+7)>>3]; + unsigned char world_pvsbits[(32768+7)>>3]; // FIXME: buffer overflow on huge maps // TODO: dynamic resize according to r_refdef.worldmodel->brush.num_leafs - unsigned char world_leafvisible[32768]; + unsigned char world_leafvisible[32768]; // FIXME: buffer overflow on huge maps // TODO: dynamic resize according to r_refdef.worldmodel->num_surfaces - unsigned char world_surfacevisible[262144]; + unsigned char world_surfacevisible[262144]; // FIXME: buffer overflow on huge maps // if true, the view is currently in a leaf without pvs data qboolean world_novis; }